# Tallyfy Products Documentation > Tallyfy is a workflow management platform that helps non-technical users document, track, and improve business processes through AI-powered templates, automated task management, and real-time progress monitoring. This document contains the complete documentation for all Tallyfy products, organized hierarchically with full content included for AI processing. ---## Answers - **[Overview](https://tallyfy.com/products/answers/)**: Tallyfy Answers is an AI-powered search platform that combines semantic understanding with keyword matching to help users find information through natural language queries and offers advantages over traditional search solutions like Elasticsearch and Algolia through built-in neural capabilities and simpler deployment. ## Next-generation search capabilities Tallyfy Answers is a complete search solution that combines advanced AI technology with intelligent document understanding. You get instant semantic search that understands meaning - not just keywords. The platform includes four core capabilities: * **Smart Document Storage** - Intelligent indexing that understands your content structure and relationships * **Hybrid Search Intelligence** - Combines meaning-based search with keyword matching for optimal results * **Content Recommendations** - Automatically suggests related documents and information * **Batch Processing** - Efficiently handles large document collections with background processing Unlike traditional search vendors, Tallyfy Answers integrates neural search capabilities directly into the core experience. This means your users get smarter, more relevant results without complex configuration. Tallyfy Answers delivers professional-grade AI search capabilities at a fraction of the cost of solutions like Elasticsearch, Algolia, Typesense, or Meilisearch. :::note[Important distinction] Tallyfy Answers works differently from search engines like Google or Bing. Instead of crawling websites, you push JSON-formatted data directly into Tallyfy Answers. Your users then search through your specific data using a customized search interface on your site or app. ::: Tallyfy Answers is currently invite-only. Schedule a discussion about implementing this search solution at https://tallyfy.com/amit ## Competitor comparison Here's how Tallyfy Answers stacks up against other leading search technology solutions: ### Key differentiators | Feature | Tallyfy Answers | Elasticsearch | Algolia | TypeSense | Meilisearch | |---------|----------------|--------------|---------|-----------|-------------| | **Architecture** | Vector database with AI integration[^1] | Inverted index[^2] | Inverted index with AI features | Inverted index | Inverted index | | **AI capabilities** | Native LLM integration | Limited, requires add-ons | NeuralSearch add-on | Limited | Limited | | **Semantic search** | Built-in | Requires custom setup | Available as add-on | Limited | Limited | | **Deployment complexity** | Low (fully managed) | High | Low | Medium | Medium | | **Scaling complexity** | Low | High | Low | Medium | Medium | ### Strengths versus competitors **Compared to Elasticsearch:** - Deploy in hours instead of weeks - no specialized DevOps knowledge required - Built-in AI and semantic search work immediately without complex configuration - Costs significantly less for typical use cases - Handles natural language queries out of the box - Automatic relevance tuning based on user behavior **Compared to Algolia:** - Native AI understands context and meaning - not just matching keywords - Semantic search built into the core product (not an expensive add-on) - Transparent pricing that scales with your growth - Unified vector and keyword search in a single query **Compared to TypeSense:** - Advanced LLM integration understands complex, conversational queries - Handles ambiguous searches and typos intelligently - Complete solution works immediately - minimal custom development needed - Better relevance for long-tail searches **Compared to Meilisearch:** - Unlimited query length - search with full sentences or paragraphs - Scales effortlessly to millions of documents - Self-improving AI learns from user interactions - Production-ready features for professional deployments ### Best suited use cases Tallyfy Answers excels in these specific scenarios: 1. **Content-rich applications** - Find answers buried in thousands of documents using natural language 2. **Customer support knowledge bases** - Users ask questions conversationally and get direct answers 3. **Product catalogs** - Search by features, benefits, or use cases (not just product names) 4. **Documentation sites** - Developers find code examples and explanations instantly 5. **E-commerce platforms** - Shoppers describe what they want in their own words Traditional search engines match keywords but miss the actual meaning behind queries. A user searching "how to reduce monthly costs" won't find an article titled "Budget optimization strategies" with keyword search alone. Tallyfy Answers understands both explicit keywords and implicit meaning. Your users find what they need - even when they don't know the exact terms to search for. [^1]: Stores data as mathematical vectors enabling similarity searches vs traditional keyword indexing [^2]: Traditional search structure mapping words to document locations, fast for keyword matches ### Answers - **[Authentication](https://tallyfy.com/products/answers/authentication/)**: Tallyfy Answers authentication requires an API key in the Authorization Bearer header with centralized identity management through account.tallyfy.com that supports multi-organization switching and follows security best practices for key storage and usage. ## Authentication with Tallyfy Answers All API requests to Tallyfy Answers require authentication using an API key. This API key validates your identity and permissions when accessing Tallyfy Answers endpoints. Tallyfy uses a centralized identity and access management system[^1] at [account.tallyfy.com](https://account.tallyfy.com) for all products. This system handles sign up, sign in, SSO, and account management functions like password recovery across all Tallyfy products. If your account is a member of multiple organizations, you can easily switch between them. Click your name/profile picture in the top-right corner and select "Switch organization" to access other roles and organizations associated with your account. ### Required API key header Add the following header to all your Tallyfy Answers API requests: ``` Authorization: Bearer your_api_key ``` Replace `your_api_key` with the actual API key provided to your Tallyfy account. ### Obtaining a Tallyfy Answers API key To get a Tallyfy Answers API key: 1. Log in to your Tallyfy Answers account 2. Navigate to the **API Settings** section 3. Click **Generate API Key** 4. Copy the generated key for use in your applications ### API key security best practices - Do not share your Tallyfy API key in public repositories or client-side code - Store your API key in environment variables or secure configuration files - Regenerate your API key if you suspect it has been compromised - Use different API keys for development and production environments ### Example authenticated request ```bash curl -X GET https://go.tallyfy.com/api/answers/collections/my_collection \ -H "Authorization: Bearer " \ -H "Content-Type: application/json" ``` ### Troubleshooting authentication errors If you receive a `401 Unauthorized[^2]` response, check that: - Your Tallyfy Answers API key is valid and active - You've correctly included the `Authorization: Bearer` header - Your account has the necessary permissions for the requested operation [^1]: Handles SSO, multi-org switching, and unified auth across all Tallyfy products via OAuth 2.0 [^2]: HTTP status code returned when API key is missing, invalid, or lacks required permissions - **[Answers neural search information](https://tallyfy.com/products/answers/pricing/)**: Tallyfy Answers provides neural search capabilities that you can learn more about by contacting their team directly for detailed information and custom solutions tailored to your specific search requirements ## How can I get more information about Tallyfy Answers neural search? Please reach out to us to learn more about Tallyfy Answers neural search capabilities. Our team can provide detailed information and custom solutions tailored to your search requirements. [^1]: Significant cost savings through optimized vector search and shared infrastructure - **[Collections](https://tallyfy.com/products/answers/collections/)**: Collections in Tallyfy Answers are organizational structures that group similar objects together like database tables and provide features for searching filtering and managing data with automatic schema detection and complete CRUD operations. ## What are collections in Tallyfy Answers? Collections in Tallyfy Answers are organizational structures that group similar objects together. Each collection works like a table in a relational database, letting objects be compared, filtered, searched, and ranked. ### How do collections work in Tallyfy Answers? A Tallyfy Answers collection is: - A logical container for related objects - Like a table in a traditional database - Built for organizing data with similar structures - Flexible enough to adapt as your data changes ### What features do collections provide? Tallyfy Answers collections give you several key features: - **Dynamic schema detection[^1]**: Tallyfy Answers automatically detects data types from your objects - **Efficient organization**: Group related objects to make management easier - **Searchability**: Search across all objects within a collection - **Scalability**: Collections can hold thousands of objects[^2] - **Metadata**: Store and get information about the collection itself ### What operations can you perform on collections? Tallyfy Answers gives you complete collection management capabilities: - [Create a collection](/products/answers/collections/create-collection/) - Set up a new data container - [Get a collection](/products/answers/collections/get-collection/) - Retrieve details about a specific collection - [Get all collections](/products/answers/collections/get-all-collections/) - List all your collections - [Update a collection](/products/answers/collections/update-collection/) - Modify collection properties - [Delete a collection](/products/answers/collections/delete-collection/) - Remove a collection and its objects ### What are the best practices for using collections? Think about these guidelines when working with Tallyfy Answers collections: - Use clear, descriptive names for your collections - Group similar objects with consistent structures - Create separate collections for very different data types - Plan your collection structure before bringing in large datasets - Use collection names that show what objects they contain Browse all Tallyfy Answers collection management operations below: [^1]: Uses PostgreSQL JSONB to analyze object properties and infer types like string, number, boolean, date automatically [^2]: Default pagination at 15 items with configurable max limit for API performance optimization - **[Objects](https://tallyfy.com/products/answers/objects/)**: Objects in Tallyfy Answers are fundamental JSON-formatted data records that belong to collections and can be indexed retrieved and searched using either custom or auto-generated unique identifiers while supporting flexible schema-less structure and various management operations. ## What are objects in Tallyfy Answers? Objects are the fundamental data records in Tallyfy Answers. Each object represents a single item that can be indexed, retrieved, and searched within your collections. ### How do objects work in Tallyfy Answers? An object in Tallyfy Answers: - Contains data in JSON format - Belongs to a specific collection - Has a unique identifier (either custom or auto-generated) - Can store multiple properties and values - Is fully searchable once indexed ### How do object identifiers work? Tallyfy Answers handles object identifiers in two ways: 1. **Custom IDs**: If your object includes an `id` field of type string, Tallyfy Answers will use this as the identifier: ```json { "id": "product-123", "name": "Wireless Headphones", "price": 79.99 } ``` 2. **Auto-generated IDs**: If no `id` field is provided, Tallyfy Answers will automatically generate a unique identifier: ```json { "name": "Wireless Headphones", "price": 79.99 } ``` The `id` field is special and doesn't need to be explicitly defined in your Tallyfy Answers collection schema. ### How flexible is object structure? Unlike traditional databases, Tallyfy Answers doesn't require you to predefine a rigid schema before adding objects. The system automatically detects properties and data types as you index objects, providing flexibility as your data evolves. ### What operations can you perform on objects? With Tallyfy Answers, you can perform these object operations: - [Index a single object](/products/answers/objects/index-single-object/) - [Index multiple objects in bulk](/products/answers/objects/index-multiple-objects/) - [Retrieve specific objects](/products/answers/objects/get-object/) - [Delete objects](/products/answers/objects/delete-object/) - Search for objects within collections ### What are the best practices for objects? - Use consistent property names across similar objects - Choose meaningful custom IDs when possible - Structure nested data appropriately for searching - Consider batching multiple objects[^1] for more efficient indexing - Include all relevant data for search in your objects Browse all Tallyfy Answers object management operations below: [^1]: Bulk indexing via the import endpoint reduces API calls and improves performance vs single operations - **[Search](https://tallyfy.com/products/answers/search/)**: Tallyfy Answers search combines AI semantic understanding with traditional keyword matching to deliver relevant results through natural language queries and exact term searches with smart filtering and instant results. ## How does search work in Tallyfy Answers? In Tallyfy Answers, a search operation combines intelligent AI understanding with traditional keyword matching to deliver the most relevant results. Search allows you to find specific objects within your Tallyfy Answers collections[^2] using natural language queries or specific terms. The system understands both the meaning behind your query and exact keyword matches. ### What makes Tallyfy Answers search different? Tallyfy Answers uses **hybrid search technology[^1]** that combines: - **Semantic Understanding** - Understands the meaning and context of your search query - **Keyword Matching** - Finds exact terms and phrases in your documents - **Smart Filtering** - Filter results by source or collection type - **Instant Results** - Get relevant results as you type ### How do you perform a search? Making a search request is simple: ```bash GET /collections/{collection_name}/search/{query} ``` **Optional parameters:** - `source` - Filter results by specific data source - `origin` - Filter by content origin **Example:** ```bash curl "https://answers.tallyfy.com/collections/docs/search/workflow automation" \ -H "Authorization: Bearer your_api_key" ``` ### What search features are available? - **Natural Language Queries** - Ask questions like "How do I automate workflows?" - **Multi-word Search** - Search with full sentences or phrases - **Source Filtering** - Narrow results to specific content sources - **Related Suggestions** - Get recommendations for similar content - **Real-time Results** - See results update as you refine your query [^1]: Combines vector embeddings for semantic similarity with BM25 algorithm for keyword relevance scoring [^2]: Similar to database tables, collections group related JSON objects with auto-detected schemas - **[Tasks](https://tallyfy.com/products/answers/tasks/)**: Tallyfy Answers uses background task processing to handle long-running operations like batch imports and data processing without blocking API requests while providing monitoring and cancellation capabilities for efficient task management. ## How do background tasks work in Tallyfy Answers? Tallyfy Answers uses background task processing to handle long-running operations without blocking your API requests. This ensures that large batch imports and data processing jobs don't cause timeouts or performance issues. ### What are background tasks? Background tasks in Tallyfy Answers handle: - **Batch Document Imports** - Processing large collections of documents for indexing - **Data Processing Jobs** - Converting and analyzing content for search optimization - **Collection Updates** - Making bulk changes to existing data - **Maintenance Operations** - System cleanup and optimization tasks ### How do you monitor running tasks? View all currently running background tasks: ```bash GET /tasks ``` **Example:** ```bash curl "https://answers.tallyfy.com/tasks" \ -H "Authorization: Bearer your_api_key" ``` ### How do you cancel a running task? Stop a specific background task by name: ```bash DELETE /tasks/{task_name} ``` **Example:** ```bash curl -X DELETE "https://answers.tallyfy.com/tasks/batch_import_docs" \ -H "Authorization: Bearer your_api_key" ``` ### What task information is available? When you list running tasks, you'll see: - **Task Name** - Unique identifier for the background operation - **Status** - Current state of the task (running, queued, completed) - **Progress** - How much of the task has been completed - **Start Time** - When the task began processing - **Estimated Completion** - Predicted time remaining ### When should you use task management? Task management is useful for: 1. **Large Imports** - Monitor progress of bulk document uploads 2. **System Maintenance** - Check status of scheduled operations 3. **Troubleshooting** - Cancel stuck or problematic tasks 4. **Resource Management** - Prevent system overload by managing concurrent operations 5. **User Experience** - Provide progress updates for long-running operations ### What are best practices for task management? - **Monitor Long Operations** - Check task status for imports over 1000 documents[^1] - **Cancel Stuck Tasks** - Remove tasks that appear frozen or taking too long - **Plan Large Imports** - Schedule big data loads during low-usage periods[^2] - **Regular Cleanup** - Cancel completed or failed tasks to keep the queue clean [^1]: Processing time varies: ~5-10 mins per 1000 docs depending on content size and complexity [^2]: Typically weekends or 2-6 AM in your org's primary timezone for optimal performance ### Collections - **[Create a collection](https://tallyfy.com/products/answers/collections/create-collection/)**: To create collections in Tallyfy Answers you must first make a POST request to the /v1/collections endpoint with a unique collection name and optional description before adding any objects to the collection. ## How do you create collections in Tallyfy Answers? Before adding objects to Tallyfy Answers, you must first create a collection. Each collection requires a unique name, and Tallyfy Answers automatically detects the data types of your objects as you index them. ### API endpoint ``` POST /v1/collections ``` ### Request body The request body should contain a JSON object with the following collection properties: | Parameter | Type | Required | Description | |-----------|------|----------|-------------| | `name` | string | Yes | Unique name for the collection (can include letters, numbers, hyphens, and underscores) | | `description` | string | No | Optional description explaining the collection's purpose | Example request body: ```json { "name": "products", "description": "Collection of product information including names, descriptions, and pricing" } ``` ### Response A successful collection creation request returns a `201 Created[^1]` status code and a JSON response containing: ```json { "name": "products", "description": "Collection of product information including names, descriptions, and pricing", "created_at": "2023-08-15T14:32:21Z" } ``` ### Error scenarios | Status | Description | |--------|-------------| | 400 | Invalid request format or collection name | | 409 | Collection name already exists | ### Example request ```bash curl -X POST https://go.tallyfy.com/api/collections \ -H "X-Answers-API-Key: " \ -H "Content-Type: application/json" \ -d '{ "name": "products", "description": "Collection of product information" }' ``` ### What data types does Tallyfy Answers support? Tallyfy Answers automatically detects these data types when you index objects:
Data Type Example Description
string "Wireless Headphones" Text values that can be searched and filtered
list of strings ["electronics", "audio"] Arrays of text values for multi-value fields
### What are collection naming best practices? - Use lowercase letters, numbers, hyphens, and underscores - Choose descriptive names that reflect the content (e.g., "products", "users", "articles") - Avoid spaces and special characters - Keep collection names concise but meaningful - Use consistent naming conventions across all collections [^1]: HTTP status indicating successful resource creation, distinct from 200 OK for updates - **[Delete a collection](https://tallyfy.com/products/answers/collections/delete-collection/)**: The DELETE endpoint permanently removes collections and all their objects from Tallyfy Answers with no recovery option and requires careful consideration of alternatives like data export or backup before execution. ## Deleting collections This endpoint allows you to permanently remove a collection and all its objects from Tallyfy Answers[^1]. This operation is irreversible and should be used with caution. :::warning[Permanent Action] Deleting a collection permanently removes all objects within it. This action cannot be undone, and there is no way to recover the data once deleted. ::: ### API endpoint ``` DELETE /v1/collections/{collection_name} ``` ### Path parameters | Parameter | Type | Required | Description | |-----------|------|----------|-------------| | `collection_name` | string | Yes | Name of the collection to delete | ### Response A successful deletion returns a `200 OK` status code with a confirmation response: ```json { "name": "products", "status": "deleted" } ``` ### Error scenarios | Status | Description | |--------|-------------| | 404 | Collection not found | | 400 | Invalid collection name format | | 403 | Permission denied (if applicable) | ### Example request ```bash curl -X DELETE https://go.tallyfy.com/api/collections/products \ -H "X-Answers-API-Key: your_api_key" ``` ### When to delete a collection Consider deleting a collection when: - The data is no longer needed for any purpose - You need to rebuild a collection with a different structure - You want to remove test or development data - You're performing cleanup of unused resources ### Alternatives to deletion Instead of permanently deleting a collection, consider these alternatives: - Export the data before deletion for backup purposes - Create a new collection with only the objects you want to keep - Use application-level filtering to hide certain objects from users ### Best practices - Always confirm collection names before deletion - Consider implementing a confirmation step in your application - Back up important data before deletion - Use descriptive logging to track deletion operations - Verify permissions carefully to prevent unauthorized deletions [^1]: Tallyfy's semantic search and knowledge management system using vector embeddings - **[Get all collections](https://tallyfy.com/products/answers/collections/get-all-collections/)**: The GET /v1/collections endpoint retrieves a summary of all collections in your Tallyfy Answers account sorted by creation date with optional pagination parameters for limit and offset. ## Listing all collections This endpoint retrieves a summary of all collections in your Tallyfy Answers account. Collections are sorted by creation date in descending order[^1] (newest first), making it easy to find recently created collections. ### API endpoint ``` GET /v1/collections ``` ### Query parameters | Parameter | Type | Required | Default | Description | |-----------|------|----------|---------|-------------| | `limit` | integer | No | 20 | Maximum number of collections to return (1-100) | | `offset` | integer | No | 0 | Number of collections to skip (for pagination) | ### Response A successful request returns a `200 OK` status code and a JSON response containing: ```json { "collections": [ { "name": "products", "description": "Collection of product information", "object_count": 142, "created_at": "2023-08-15T14:32:21Z" }, { "name": "customers", "description": "Customer account information", "object_count": 1253, "created_at": "2023-07-28T09:15:33Z" } ], "meta": { "total_collections": 5, "limit": 20, "offset": 0 } } ``` ### Response fields | Field | Type | Description | |-------|------|-------------| | `collections` | array | List of collection summary objects | | `meta.total_collections` | integer | Total number of collections in your account | | `meta.limit` | integer | Limit value used in the request | | `meta.offset` | integer | Offset value used in the request | ### Error scenarios | Status | Description | |--------|-------------| | 400 | Invalid query parameters | ### Example request ```bash # Get first page of collections curl -X GET https://go.tallyfy.com/api/collections \ -H "X-Answers-API-Key: your_api_key" # Get second page with 10 collections per page curl -X GET "https://go.tallyfy.com/api/collections?limit=10&offset=10" \ -H "X-Answers-API-Key: your_api_key" ``` ### Pagination To paginate through large numbers of collections: 1. Make an initial request with desired `limit` 2. Check the `meta.total_collections` value to determine total pages 3. Increase the `offset` parameter by the `limit` value for each subsequent page 4. Continue until you've processed all collections Example pagination calculation: - If you have 45 total collections with a limit of 10: - Page 1: offset=0, limit=10 (collections 1-10) - Page 2: offset=10, limit=10 (collections 11-20) - Page 3: offset=20, limit=10 (collections 21-30) - Page 4: offset=30, limit=10 (collections 31-40) - Page 5: offset=40, limit=10 (collections 41-45) ### Usage scenarios - Displaying a list of collections in a management interface - Generating reports on collection usage - Performing operations across all collections - Finding collections by name when browsing [^1]: Uses PostgreSQL's JSONB indexing for efficient sorting even with large datasets - **[Get a collection](https://tallyfy.com/products/answers/collections/get-collection/)**: The Tallyfy Answers API provides a GET endpoint to retrieve detailed information about specific collections including metadata schema information and object counts using the collection's unique name. ## Retrieving collection details This endpoint allows you to fetch detailed information about a specific collection in Tallyfy Answers using its unique name. The response includes collection metadata, schema information, and object counts. ### API endpoint ``` GET /v1/collections/{collection_name} ``` ### Path parameters | Parameter | Type | Required | Description | |-----------|------|----------|-------------| | `collection_name` | string | Yes | Name of the collection to retrieve | ### Response A successful request returns a `200 OK` status code and a JSON response containing: ```json { "name": "products", "description": "Collection of product information", "schema": { "name": { "type": "string" }, "description": { "type": "string" }, "price": { "type": "number" }, "categories": { "type": "string[]" } }, "object_count": 142, "created_at": "2023-08-15T14:32:21Z", "updated_at": "2023-09-01T09:45:33Z" } ``` ### Response fields | Field | Type | Description | |-------|------|-------------| | `name` | string | The collection's unique identifier | | `description` | string | Optional description of the collection | | `schema` | object | Auto-detected schema based on indexed objects[^1] | | `object_count` | number | Total number of objects in the collection | | `created_at` | string | ISO timestamp when the collection was created | | `updated_at` | string | ISO timestamp when the collection was last modified | ### Error scenarios | Status | Description | |--------|-------------| | 404 | Collection not found | | 400 | Invalid collection name format | ### Example request ```bash curl -X GET https://go.tallyfy.com/api/collections/products \ -H "X-Answers-API-Key: your_api_key" ``` ### Common uses - Checking a collection's current schema - Verifying the number of objects in a collection - Retrieving collection metadata before performing operations - Confirming a collection exists before adding objects [^1]: Schema types are inferred from first 100 objects; explicit schemas can override auto-detection - **[Update a collection](https://tallyfy.com/products/answers/collections/update-collection/)**: The PATCH endpoint allows modifying existing collection properties like descriptions in Tallyfy Answers while maintaining limitations such as unchangeable collection names and automatic schema detection. ## Updating collection properties This endpoint allows you to modify certain properties of an existing collection in Tallyfy Answers, such as its description or configuration settings. The collection name cannot be changed once it's created. ### API endpoint ``` PATCH /v1/collections/{collection_name} ``` ### Path parameters | Parameter | Type | Required | Description | |-----------|------|----------|-------------| | `collection_name` | string | Yes | Name of the collection to update | ### Request body The request body should contain a JSON object with the properties you want to update: | Parameter | Type | Required | Description | |-----------|------|----------|-------------| | `description` | string | No | New description for the collection | Example request body: ```json { "description": "Updated collection of premium electronics products" } ``` ### Response A successful update returns a `200 OK` status code and a JSON response containing the updated collection: ```json { "name": "products", "description": "Updated collection of premium electronics products", "schema": { "name": { "type": "string" }, "price": { "type": "number" }, "categories": { "type": "string[]" } }, "created_at": "2023-08-15T14:32:21Z", "updated_at": "2023-09-05T10:15:42Z" } ``` ### Error scenarios | Status | Description | |--------|-------------| | 404 | Collection not found | | 400 | Invalid request format or parameters | ### Example request ```bash curl -X PATCH https://go.tallyfy.com/api/collections/products \ -H "X-Answers-API-Key: " \ -H "Content-Type: application/json" \ -d '{ "description": "Updated collection of premium electronics products" }' ``` ### Common update scenarios There are several situations where updating a collection is useful: - **Improving documentation**: Add or update the description to better explain the collection's purpose - **Adjusting configurations**: Modify search settings or other configuration parameters - **Refining metadata**: Update metadata fields to provide better context for the collection ### Limitations - The collection name cannot be changed after creation - Schema changes happen automatically as objects are indexed[^1], not through this endpoint - Certain system-level properties cannot be modified ### Best practices - Make incremental updates to avoid disrupting existing processes - Use descriptive descriptions to help users understand the collection's purpose - Document changes to collection properties for future reference [^1]: Tallyfy auto-detects data types (string, number, array) when new objects are added to collections ### Objects - **[Delete an object](https://tallyfy.com/products/answers/objects/delete-object/)**: The DELETE endpoint permanently removes specific objects from Tallyfy Answers collections using unique identifiers and returns confirmation upon successful deletion with no recovery option available. ## Deleting objects from collections This endpoint allows you to permanently remove a specific object from a Tallyfy Answers collection using its unique identifier. Once deleted, an object cannot be recovered. ### API endpoint ``` DELETE /v1/collections/{collection_name}/objects/{object_id} ``` ### Request parameters | Parameter | Type | Required | Description | |-----------|------|----------|-------------| | `collection_name` | path | Yes | Name of the collection containing the object | | `object_id` | path | Yes | Unique identifier of the object to delete | ### Response A successful deletion returns a `200 OK` status code with a confirmation response: ```json { "id": "product-123", "status": "deleted" } ``` ### Error scenarios | Status | Description | |--------|-------------| | 404 | Object or collection not found | | 400 | Invalid object ID format | | 403 | Permission denied (if applicable) | ### Example request ```bash curl -X DELETE https://go.tallyfy.com/api/collections/products/objects/product-123 \ -H "X-Answers-API-Key: your_api_key" ``` ### Important considerations :::warning[Permanent Action] Object deletion is permanent and cannot be undone. There is no "trash" or "recycle bin" for deleted objects. ::: - Verify that you have the correct object ID before deletion - Consider archiving objects in your application logic instead of deleting them if you might need them later - Deleting an object will remove it from search results immediately - If you need to delete multiple objects, you may need to make separate API calls for each one - Consider implementing confirmation workflows in your application before calling this endpoint ### Alternative approaches Instead of actually deleting objects, consider these alternatives: - Add a "status" field to mark objects as inactive - Move objects to an "archive" collection - Implement soft deletion[^1] by adding a "deleted_at" timestamp field [^1]: Records marked as deleted but retained in database, unlike hard deletion which permanently removes data - **[Index multiple objects](https://tallyfy.com/products/answers/objects/index-multiple-objects/)**: The batch import endpoint enables efficient indexing of multiple objects into Tallyfy Answers collections through a single API call that processes JSON arrays and provides comprehensive error handling for large-scale data operations. ## Batch importing multiple objects This endpoint allows you to efficiently index multiple objects into Tallyfy Answers in a single API call. It significantly outperforms making multiple individual object creation requests, especially for large datasets or initial data loading. Large batch imports are processed in the background, allowing you to monitor progress and cancel operations if needed using the [Tasks](/products/answers/tasks/) endpoints. ### API endpoint ``` POST /collections/{collection_name}/batch ``` ### Request parameters | Parameter | Type | Required | Description | |-----------|------|----------|-------------| | `collection_name` | path | Yes | Name of the collection to import objects into | ### Request body format: JSON Array The request body must be a JSON array containing multiple document objects. Each object should include the required fields for your collection schema. Example JSON array format for three objects: ```json [ { "uid": "article-123", "title": "Getting Started Guide", "content": "Complete guide to getting started...", "url": "https://example.com/guide", "source": "Documentation", "snippet": "Quick start guide for new users" }, { "uid": "article-456", "title": "Advanced Features", "content": "Advanced functionality overview...", "url": "https://example.com/advanced", "source": "Documentation", "snippet": "Deep dive into advanced capabilities" } ] ``` ### Content-Type header Set the `Content-Type` header to: - `application/json` ### Response A successful request returns a `200 OK` status code and a summary of the import operation: ```json { "success": true, "count": 3, "errors": [] } ``` If some objects fail to import while others succeed, you'll receive a `207 Multi-Status[^1]` response: ```json { "success": true, "count": 2, "errors": [ { "line": 2, "error": "Invalid object format at line 2", "object": "{malformed json}" } ] } ``` ### Error scenarios | Status | Description | |--------|-------------| | 400 | Invalid JSONLines format or request body | | 404 | Collection not found | | 413 | Request body too large | ### Example request using curl ```bash curl -X POST "https://answers.tallyfy.com/collections/docs/batch" \ -H "Authorization: Bearer your_api_key" \ -H "Content-Type: application/json" \ -d '[ { "uid": "guide-123", "title": "Getting Started", "content": "Complete guide to getting started with our platform...", "url": "https://example.com/guide", "source": "Documentation", "snippet": "Quick start guide for new users" } ]' ``` ### Best practices for batch imports - **Size limitations**: Keep individual requests under 5MB - **Chunking**: For large datasets, break imports into smaller batches of 100-1000 objects[^2] - **ID handling**: You can mix objects with and without custom IDs in the same import - **Error handling**: Process the errors array in the response to identify and fix failed objects - **Parallel imports**: For very large datasets, you can make multiple parallel import requests to different collections ### When to use batch import - Initial data population - Regular data synchronization from external systems - Bulk updates to multiple objects - Periodic content refreshes [^1]: HTTP status code indicating partial success - some operations succeeded while others failed [^2]: Optimal range balances memory usage, network timeout risk, and API processing efficiency - **[Get an object](https://tallyfy.com/products/answers/objects/get-object/)**: The Tallyfy Answers API endpoint retrieves complete individual object data from collections using unique identifiers through a GET request that returns full object properties including system-generated timestamps. ## How do you retrieve individual objects from Tallyfy Answers? This endpoint allows you to fetch a specific object from a collection using its unique identifier. Use this endpoint to access the complete data for an individual record. ### API endpoint ``` GET /v1/collections/{collection_name}/objects/{object_id} ``` ### Request parameters | Parameter | Type | Required | Description | |-----------|------|----------|-------------| | `collection_name` | path | Yes | Name of the collection containing the object | | `object_id` | path | Yes | Unique identifier of the object to retrieve | ### Response A successful object retrieval request returns a `200 OK` status code and a JSON object containing all the properties of the requested object: ```json { "id": "product-123", "name": "Wireless Headphones", "description": "Premium noise-canceling headphones with 20-hour battery life", "price": 79.99, "categories": ["electronics", "audio", "wireless"], "created_at": "2023-08-15T14:32:21Z", "updated_at": "2023-08-15T14:32:21Z" } ``` ### Error scenarios | Status | Description | |--------|-------------| | 404 | Object or collection not found | | 400 | Invalid object ID format | ### Example request ```bash curl -X GET https://go.tallyfy.com/api/collections/products/objects/product-123 \ -H "X-Answers-API-Key: your_api_key" ``` ### What are important usage considerations? - Object retrieval is suitable for displaying detailed information about a specific item - For searching across multiple objects, use the [search endpoint](/products/answers/search/) instead - The Tallyfy Answers API returns the complete object with all its properties - System fields like `created_at` and `updated_at` are automatically included[^1] [^1]: ISO 8601 format timestamps (YYYY-MM-DDTHH:mm:ssZ) tracked at microsecond precision in PostgreSQL - **[Index a single object](https://tallyfy.com/products/answers/objects/index-single-object/)**: The Tallyfy Answers API endpoint enables adding single objects to collections in real-time through POST requests with JSON data ideal for individual record creation and testing while bulk operations should use the import endpoint for better performance. ## Indexing individual objects This endpoint allows you to add a single object to a specific collection in Tallyfy Answers. Use this method when you need to index objects in response to real-time events or user actions in your application. ### When to use this endpoint This endpoint is ideal for: - Adding individual records as they're created - Updating existing objects with new information - Testing your integration with Tallyfy Answers - Low-volume indexing operations For high-volume operations, the [import objects endpoint](/products/answers/objects/index-multiple-objects/) offers significantly better performance. ### API endpoint ``` POST /v1/collections/{collection_name}/objects ``` ### Request parameters | Parameter | Type | Required | Description | |-----------|------|----------|-------------| | `collection_name` | path | Yes | Name of the collection where the object will be indexed | ### Request body The request body should contain a JSON object with the data you want to index. For example: ```json { "id": "product-123", "name": "Wireless Headphones", "description": "Premium noise-canceling headphones with 20-hour battery life", "price": 79.99, "categories": ["electronics", "audio", "wireless"] } ``` ### Response A successful request returns a `201 Created[^1]` status code and a JSON response containing: ```json { "id": "product-123", "status": "success" } ``` ### Error scenarios | Status | Description | |--------|-------------| | 400 | Malformed request or invalid object format | | 404 | Collection not found | | 409 | Object ID conflict (when using custom IDs) | | 413 | Object size too large | ### Example request ```bash curl -X POST https://go.tallyfy.com/api/collections/products/objects \ -H "X-Answers-API-Key: " \ -H "Content-Type: application/json" \ -d '{ "id": "product-123", "name": "Wireless Headphones", "price": 79.99, "categories": ["electronics", "audio"] }' ``` ### Performance considerations For indexing multiple objects, consider using the bulk import endpoint instead of making multiple individual requests. The bulk endpoint is optimized for higher throughput and will significantly reduce API request overhead[^2]. [^1]: HTTP status indicating successful resource creation with location header [^2]: Network latency and processing time per request, typically milliseconds to seconds ### Search - **[Find similar objects](https://tallyfy.com/products/answers/search/find-similar-objects/)**: Tallyfy Answers provides a recommendation endpoint that uses vector embeddings and semantic similarity to find objects related to a specified reference object by comparing vector distances and ranking results by similarity scores. ## How do you find similar objects in Tallyfy Answers? The recommendation endpoint allows you to discover objects similar to a specified reference object. This similarity search uses vector embeddings to find objects with related characteristics, which is useful for recommendation systems, content discovery, and finding related items. ### How does similarity search work in Tallyfy Answers? Tallyfy Answers uses semantic similarity to find related objects through this process: 1. Each object's text content is converted into vector embeddings (numerical representations) 2. When searching for similar objects, Tallyfy compares vector distances 3. Objects with closer vector distances are considered more similar 4. Results are ranked by similarity score from most to least similar ### API endpoint ``` GET /collections/{collection_name}/recommend/{object_id} ``` ### Path parameters | Parameter | Type | Required | Description | |-----------|------|----------|-------------| | `collection_name` | string | Yes | Name of the collection to search in | | `object_id` | string | Yes | ID of the reference object to find similar objects to | ### Query parameters | Parameter | Type | Required | Default | Description | |-----------|------|----------|---------|-------------| | `limit` | integer | No | 4 | Maximum number of similar objects to return (1-20) | ### Response A successful similarity search request returns a `200 OK` status code and a JSON response containing: ```json { "results": [ { "id": "product-456", "score": 0.89, "document": { "name": "Bluetooth Speaker", "description": "Portable waterproof speaker with 20-hour battery life", "price": 129.99, "categories": ["electronics", "audio"] } }, { "id": "product-789", "score": 0.72, "document": { "name": "Wireless Earbuds", "description": "Premium noise-canceling earbuds with charging case", "price": 99.99, "categories": ["electronics", "audio"] } } ], "meta": { "limit": 10, "found": 2 } } ``` ### Response fields | Field | Type | Description | |-------|------|-------------| | `results` | array | List of similar objects with similarity scores | | `results[].id` | string | Unique identifier of the similar object | | `results[].score` | float | Similarity score (0.0-1.0)[^2] where higher is more similar | | `results[].document` | object | Full content of the similar object | | `meta.limit` | integer | Maximum number of results requested | | `meta.found` | integer | Total number of similar objects found | ### Error scenarios | Status | Description | |--------|-------------| | 404 | Collection or reference object not found | | 400 | Invalid parameters or filter syntax | ### Example request ```bash # Find objects similar to article-123, limit to 5 results curl -X GET "https://answers.tallyfy.com/collections/docs/recommend/article-123?limit=5" \ -H "Authorization: Bearer your_api_key" ``` ### What are common use cases for similarity search? - **Product recommendations**: "Customers who viewed this also viewed..." - **Content discovery**: Finding related articles or documentation - **Similarity matching**: Identifying near-duplicate content - **Alternative suggestions**: Offering similar options when an item is unavailable ### What are best practices for similarity search? - Start with a lower `min_score` threshold and adjust based on result quality - Use the `filter` parameter to combine similarity with business rules - For better recommendations, ensure your objects contain rich, descriptive text - Include diverse object attributes to improve similarity matching accuracy [^1]: Multi-dimensional numerical arrays representing text meaning, typically 768-1536 dimensions [^2]: Cosine similarity scoring where perfect match equals 1.0, high similarity above 0.8, low below 0.5 --- ## Denizen - **[Overview](https://tallyfy.com/products/denizen/)**: Tallyfy Denizen is a free API service that automatically delivers royalty-free location-specific photos based on visitor IP geolocation and has shown measurable improvements in conversion rates and user engagement on registration pages. ## What is Tallyfy Denizen? Tallyfy Denizen is a free API service that delivers location-specific royalty-free photos based on the user's geographic location. The service accepts city (optional) and country (required) parameters to return relevant images. Photos are sourced from curated collections including Unsplash and other royalty-free image providers. The service automatically detects location from the user's IP address - no manual input required from end users. Tallyfy uses a centralized identity and access management system at [account.tallyfy.com](https://account.tallyfy.com) for all products. This system handles sign up, sign in, SSO, and account management functions like password recovery across all Tallyfy products. If your account belongs to multiple organizations, you can easily switch between them. Click your name/profile picture in the top-right corner and select "Switch organization" to access other roles and organizations connected to your account. ## How Tallyfy Denizen works 1. When a user visits your site, Tallyfy Denizen detects their location using IP geolocation[^1] 2. The service retrieves royalty-free images specific to that location 3. Images are delivered through a simple RESTful API endpoint ## Business benefits ### Results Tallyfy uses Denizen on account registration pages with measurable impact: * Increased initial conversions * Increased trial user engagement[^2] (one week after signup) ### Implementation suggestions Results may vary based on your implementation. Since Tallyfy Denizen is free at any scale, we recommend: * Running A/B tests for your specific use case * Testing different page placements for the location-based images * Tracking impact on conversion and engagement metrics ## Support Reach out to us with questions or feedback at https://tallyfy.com/contact-us/ We plan to open-source Tallyfy Denizen in the future. [^1]: Uses MaxMind or similar GeoIP databases to map IP addresses to approximate geographic locations [^2]: Measured by actions taken within Tallyfy platform including process creation and task completion ### Denizen - **[Endpoints](https://tallyfy.com/products/denizen/endpoints/)**: The Tallyfy Denizen API provides a simple GET request endpoint at denizen.tallyfy.com that automatically detects user location via IP address and returns location-specific royalty-free images with city-level coverage in the United States and country-level coverage elsewhere without requiring authentication. ## Tallyfy Denizen API endpoints ### Base URL ``` https://denizen.tallyfy.com/ ``` ### Using Tallyfy Denizen To use Tallyfy Denizen in your application: 1. Make a GET request to the base URL 2. Tallyfy Denizen automatically spots user location via IP address 3. An image that fits the detected location is returned ### Response types When calling the Tallyfy Denizen API, you'll get one of two responses: * **Localized image** - An image that matches the user's detected location * **Default image** - Given when location can't be figured out or no specific images exist for that location ## Geographic coverage ### Image availability by region * **United States**: City-level images available (more detailed) * **Other countries**: Country-level images only (no city-specific images) ### Technical implementation Tallyfy Denizen is made for performance and reliability: * Hosted on Cloudflare Pages[^1] for worldwide distribution * Built to handle high traffic volumes with minimal delays * No API key or authentication required :::note[Image Attribution] All images are royalty-free and come from collections like Unsplash. No attribution is needed in your implementation. ::: ## Performance and support Tallyfy Denizen is built to scale with any amount of traffic. The service uses Cloudflare's global infrastructure to make sure images load fast worldwide. We welcome feedback on your implementation results. Reach out to us at https://tallyfy.com/contact-us/ to share your use case or get help. [^1]: CDN platform with edge locations globally for fast response times [^2]: Uses GeoIP2 database for location detection, with city-level accuracy in many cases --- ## Manufactory - **[Overview](https://tallyfy.com/products/manufactory/)**: Tallyfy Manufactory is an API-based events lifecycle engine that provides scalable infrastructure for collecting querying and triggering events from authenticated users while offering transparent per-event pricing and letting organizations maintain full control over their own analytics and visualization tools. Tallyfy Manufactory is an events lifecycle engine that collects, queries, and triggers events from authenticated users or devices. Think of it as your event infrastructure backbone - scalable, reliable, and refreshingly straightforward. This API-based service handles the essential plumbing of event management while you maintain complete control over analytics and visualization. We manage the infrastructure complexity so you can focus on extracting insights from your data. Tallyfy Manufactory serves organizations with data science teams and developers who need robust event management without the complexity. You get industrial-strength infrastructure while keeping full ownership of your analysis and triggered actions. As a cost-effective alternative to platforms like Mixpanel, Heap Analytics, and Amplitude, Manufactory makes sense when you can build your own visualizations. Why pay premium prices for features you'll build anyway? The event lifecycle in Tallyfy Manufactory follows three simple stages: 1. **Ingesting**: Collect events through REST API or websocket at any scale. Events support rich metadata and user profile information, positioning Tallyfy Manufactory as a practical alternative to costly event collection tools like Mixpanel, Google Analytics, Amplitude, and Snowflake. 2. **Querying**: Access your data without restrictions on scale, frequency, or query complexity. Most users connect their favorite BI tools (Tableau, PowerBI) to build custom dashboards or embed visualizations directly into applications. Need your data elsewhere? Export everything as an SQLite file[^2] anytime - your data remains yours. 3. **Triggers**: Set up webhooks that fire when specific conditions occur, enabling real-time responses to meaningful events in your system. ## Pricing Tallyfy Manufactory pricing is straightforward: you pay only for the total number of stored events, calculated daily at midnight (CST)[^1]. No hidden fees for queries or triggers. No usage limits. No surprise charges. Query your data as often as you need - it's all included. ## Controlling costs with TTL Most Tallyfy Manufactory users retain all historical events for comprehensive analysis. However, you can implement a Time To Live (TTL) policy to automatically remove events after a specified period - such as 12 months. TTL policies help manage costs by purging outdated events that no longer provide business value. After all, those 5-year-old button clicks probably aren't driving today's decisions. ## Key differentiators Tallyfy Manufactory stands out as an events infrastructure service through: 1. **Transparent Pricing**: Pay only for stored events. Unlimited queries, triggers, and API calls come standard - no metered billing surprises. 2. **Real-Time Intelligence**: Configure webhooks that react instantly to event patterns. For instance: trigger an alert when a user attempts multiple upgrades within 24 hours, catching frustration signals before they become churn statistics. 3. **Bring Your Own Analytics**: Use your existing data science stack and BI tools. We provide the infrastructure; you create the insights that matter to your business. ## Limitations and exclusions Tallyfy Manufactory has clear boundaries: * **System Logging**: Specialized logging solutions handle anonymous system logs better. Tallyfy Manufactory excels with events from identified users or objects. * **Non-Technical Teams**: Without built-in dashboards or visualization tools, Tallyfy Manufactory requires technical expertise. Teams needing drag-and-drop analytics should consider full-featured platforms like Mixpanel. * **Anonymous Traffic**: Every event needs an identified profile - whether person or device. Anonymous event tracking isn't supported. * **Public Website Analytics**: Built for authenticated user environments, not anonymous visitor tracking. Need implementation guidance? Schedule a technical consultation at https://tallyfy.com/amit/ - we offer direct developer support without the sales pitch. ## Organization structure ![](https://screenshots.tallyfy.com/manufactory-org-structure-v1.png) ## Glossary * **Project**: A logical subdivision within your Tallyfy Manufactory organization. Projects typically align with different products, applications, or business units. * **Event**: A structured data point capturing a specific user or system interaction within your application. * **Actor**: The authenticated entity - person, system, or device - responsible for generating an event. * **Properties**: Key-value attributes attached to events and actors. Note that actor properties reflect current state only; historical property changes aren't tracked. * **Organization ID**: Your unique `org_id` serves as the authentication key for schema creation and websocket connections. Each organization ID maps to one customer application with its own distinct actor profiles. [^1]: Central Standard Time (UTC-6 or UTC-5 during daylight saving) [^2]: Portable database format readable by most data tools without a server ### Manufactory - **[Data types](https://tallyfy.com/products/manufactory/data-types/)**: Tallyfy Manufactory supports six data types including TEXT for unlimited character data INTEGER for whole numbers DATE TIME and TIMESTAMP for temporal values with specific formatting requirements and JSON for complex structured information with validation enforced on all incoming data. ## Supported data types Tallyfy Manufactory supports the following data types for storing your information: - **TEXT** - Stores any text data with unlimited length. Use for names, descriptions, comments, or any character-based information. - **INTEGER** - Stores whole numbers ranging from `-2,147,483,648` to `2,147,483,647`. Use for counts, IDs, or any numerical data without decimal points. - **DATE** - Stores calendar dates. All values must use the format `yyyy-mm-dd`, for example: `2023-04-15`. - **TIME** - Stores time values. All values must use the format `HH:MM:SS` in 24-hour format, for example: `14:10:00`. - **TIMESTAMP** - Stores combined date and time values. All values must use the format `yyyy-mm-dd HH:MM:SS`, for example: `2023-04-15 14:10:00`. - **JSON** - Stores data in JSON format. Use for complex structured data that needs to be stored as a single value. ### Examples of Proper Data Type Usage | Data Type | Example Value | Use Case | |-----------|---------------|----------| | TEXT | "Machine A-123" | Equipment names, comments | | INTEGER | 42 | Counts, quantities, identifiers | | DATE | 2023-04-15 | Production dates, schedule dates | | TIME | 14:10:00 | Shift times, operation times | | TIMESTAMP | 2023-04-15 14:10:00 | Event timestamps, log entries | | JSON | `{"status": "active", "temp": 72.5}` | Configuration settings, complex states | :::note[Data Validation] Manufactory validates all incoming data against these specified formats. Ensure your values match the required formats to avoid data rejection. ::: - **[Authentication](https://tallyfy.com/products/manufactory/auth/)**: Tallyfy Manufactory uses a centralized identity management system for general access while implementing customer-specific secure authentication methods that are configured through direct consultation to ensure maximum security and prevent unauthorized access to manufacturing data. ## Authentication for Manufactory Tallyfy uses a centralized identity and access management system at [account.tallyfy.com](https://account.tallyfy.com) for all products. This unified system handles sign up, sign in, SSO, and account management functions like password recovery across all Tallyfy products. If your account is a member of multiple organizations, you can easily switch between them. Click your name/profile picture in the top-right corner and select "Switch organization" to access other roles and organizations associated with your account. Tallyfy Manufactory implements a secure, customized authentication system for each customer. This approach ensures maximum security while meeting your specific implementation requirements. ### Security Approach For security reasons, we do not publish our authentication methods publicly. This security-by-design approach[^1]: - Reduces potential attack vectors - Provides customer-specific security mechanisms - Ensures only authorized systems can connect to your data - Prevents unauthorized access to your manufacturing information ### Setting Up Authentication To establish authentication for your Manufactory implementation: 1. **Initial consultation** - Discuss your security requirements with our team 2. **Custom configuration** - Receive secure authentication credentials specific to your organization 3. **Implementation** - Our team will guide you through integrating the authentication method with your systems 4. **Verification** - Test the authentication to ensure proper security ### Contact for Authentication Setup To discuss authentication options or set up access to Manufactory, please [contact our team](https://tallyfy.com/amit/) directly. A security specialist will work with you to establish the appropriate authentication method. [^1]: Architecture principle where security is built into the system from inception, not added later - **[Naming conventions](https://tallyfy.com/products/manufactory/naming_conventions/)**: Database column naming in PostgreSQL JSONB fields requires lowercase letters and underscores only with names that cannot start with numbers. ## Naming keys Please note that a column/key[^1] can only accept lower case characters and `_` **Names cannot start with numbers** `1username`: Invalid `user-name`: Invalid `username.`: Invalid `username`: Valid `username123`: Valid [^1]: Database columns in PostgreSQL JSONB fields for storing custom manufacturing data - **[Use cases and Pro integration](https://tallyfy.com/products/manufactory/use-cases/)**: Tallyfy Manufactory extends Tallyfy Pro with event lifecycle capabilities enabling automated workflow triggers based on real-time machine events along with dynamic task assignments predictive maintenance analytics and scalable integrations with third-party systems through strong APIs. ## What are Tallyfy Manufactory use cases? Tallyfy Manufactory complements Tallyfy Pro by adding event lifecycle capabilities to your workflow management. This integration enhances automation and provides real-time insights. Here’s a step-by-step approach: #### Smooth integration of event handling 1. Better Workflow Automation Triggering Workflows: - Implementation: Build connectors in Tallyfy that listen for specific events from Manufactory. - Example: When Tallyfy Manufactory detects a machine maintenance alert, it sends a webhook[^1] to Tallyfy, which automatically starts a predefined maintenance workflow. - Another example: Tallyfy Manufactory triggers a trigger based on certain event types, and this trigger launches a process. 2. Event-Based Task Assignments: - Implementation: Create a mapping system within Tallyfy to assign tasks based on specific events captured by Tallyfy Manufactory. - Example: Assign a repair task to a technician when a machine downtime event is recorded. 3. Live Status Monitoring: - Implementation: Integrate a real-time data feed from Tallyfy Manufactory into Tallyfy’s dashboard. - Example: Display live updates of workflow statuses and task progress based on the latest event data. 4. Dynamic Workflow Adjustments: - Implementation: Develop dynamic adjustment capabilities in Tallyfy workflows that respond to real-time event changes from Tallyfy Manufactory. - Example: If a critical temperature threshold is exceeded in a manufacturing process, automatically escalate the workflow to involve senior engineers. #### Enhancing user experience 1. Intelligent Reminders: - Implementation: Use event data from Tallyfy Manufactory to send context-aware reminders in Tallyfy. - Example: Notify a user to perform a task if a machine's performance drops below a certain level. 2. Proactive Alerts: - Implementation: Set up a system in Tallyfy to send proactive alerts based on predictive analysis from event data. - Example: Alert users about potential equipment failure based on trends in the time-series data[^2]. #### Expanding use cases and capabilities 1. Tailored Solutions: - Implementation: Develop industry-specific templates that combine event data from Tallyfy Manufactory with workflows in Tallyfy. - Example: For manufacturing, create a workflow template that integrates machine event data with maintenance and quality control processes. 2. Scalable Infrastructure: - Implementation: Use Tallyfy Manufactory's scalable event processing to support high-volume and complex workflows in Tallyfy. - Example: Handle large-scale production events and integrate them smoothly into detailed workflows in Tallyfy. 3. Extended Integrations: - Implementation: Enable Tallyfy Manufactory to act as an intermediary for collecting and processing events from various third-party services, which then trigger workflows in Tallyfy. - Example: Integrate with third-party CRM systems to trigger customer follow-up workflows based on sales event data. 4. API-Driven Flexibility: Implementation: Provide strong APIs for developers to use the combined functionalities of Tallyfy Manufactory and the Tallyfy app. Example: Allow external applications to trigger workflows in Tallyfy based on custom events processed by Tallyfy Manufactory. #### Advanced data handling and analytics 1. Data Ingestion and Querying: - Implementation: Utilize Tallyfy Manufactory's strong data ingestion capabilities to feed detailed event data into Tallyfy's analytics modules. - Example: Ingest event data on machine performance and visualize it within Tallyfy’s dashboard to identify trends and optimize workflows. 2. Custom Dashboards and BI Integration: - Implementation: Allow users to build custom dashboards within Tallyfy or integrate with existing BI tools like Tableau or PowerBI. - Example: Visualize workflow efficiency metrics alongside event data from Tallyfy Manufactory to provide complete insights. 3. Predictive Maintenance and Optimization: - Implementation: Use predictive analytics on time-series data from Tallyfy Manufactory to forecast maintenance needs and optimize workflows in Tallyfy. - Example: Automatically adjust maintenance schedules based on predictive analysis of machine performance trends. [^1]: HTTP POST requests sent to a specified URL when events occur, typically JSON-formatted [^2]: Data points indexed by timestamp, essential for tracking machine performance over time - **[Manufactory information](https://tallyfy.com/products/manufactory/pricing/)**: Tallyfy Manufactory provides customized implementations based on data volume storage duration API call frequency and integration options with consultation available through their contact page or sales team. ## How is Tallyfy Manufactory configured? Tallyfy Manufactory offers a customized implementation based on your specific needs. Our configuration factors include: ### What factors affect Tallyfy Manufactory configuration? - **Data volume** - The number of events collected and processed - **Storage duration** - How long your data is kept - **API call frequency** - The rate of data transmission to our platform - **Integration options** - Which collection methods you use (REST API, Websocket, CLI agent[^1]) ### How do you get Tallyfy Manufactory information? To get information for your Tallyfy Manufactory implementation: 1. **Contact our team** - Reach out through our [contact page](https://tallyfy.com/contact-us/) 2. **Schedule a consultation** - Our team will discuss your specific Tallyfy Manufactory needs 3. **Get a customized solution** - Based on your expected usage pattern[^2] and needs For immediate assistance with Tallyfy Manufactory questions, please email [sales@tallyfy.com](mailto:sales@tallyfy.com). [^1]: REST API supports batch operations, Websocket for real-time events, CLI for server-side automation [^2]: Includes daily event volume, peak load times, data retention needs, and integration frequency - **[Actors](https://tallyfy.com/products/manufactory/actors/)**: Designing actor schemas in Tallyfy Manufactory requires careful planning of user properties to ensure successful project implementation. ## Who did this? After creating a project in Tallyfy Manufactory, you can start designing and building the actors schema you want to use for your project. Planning which user properties you'll collect is crucial for a successful implementation. - **[Introduction to observability best practices](https://tallyfy.com/products/manufactory/best-practices/)**: This guide explains how observability practices enable deep understanding of event-driven systems through Tallyfy Manufactory by providing structured approaches to monitoring troubleshooting and analyzing system behavior using rich event data. This guide shows you how to implement observability best practices with Tallyfy Manufactory. You'll learn to monitor and improve your event-driven systems effectively - turning raw events into actionable insights. These articles help both beginners and experienced users maximize Manufactory's capabilities. ## What is observability? Observability lets you understand your systems' internal state through their output data. Think of it like a modern car diagnostic system - you get detailed performance data instead of just warning lights. This deep understanding proves essential for complex event-driven architectures that Tallyfy Manufactory manages. Key benefits of using an observability practice include: * **Faster troubleshooting:** Find root causes in minutes instead of hours * **Proactive problem resolution:** Fix issues before users notice them * **Better system understanding:** See exactly how your systems behave in production ## Why observability matters for Tallyfy Manufactory users Tallyfy Manufactory ingests, processes, and acts on events at scale. Observability becomes essential because it enables you to: * **Understand event lifecycles:** Track events through your systems and identify bottlenecks or failures * **Ensure process reliability:** Verify your automated workflows perform correctly * **Transform data into insights:** Convert Manufactory's event data into actionable improvements Monitoring event behavior ensures your Manufactory-driven processes remain robust and efficient. ## Core pillars of observability in the context of Manufactory Three core components matter most when implementing observability with Tallyfy Manufactory: * **Structured Events:** Well-formatted, data-rich events form the foundation for meaningful analysis. Tallyfy Manufactory requires structured event data to function effectively. * **Distributed Tracing[^1]:** Visualize an event's complete journey as it triggers actions across multiple services, including those coordinated by Manufactory. * **Metrics and Logs:** Traditional metrics and logs complement event data for comprehensive system monitoring. However, events themselves provide the deepest insights for event-driven processes. ## Overview of this guide This guide covers the key aspects of building effective observability with Tallyfy Manufactory: * [What is observability and why use it with Tallyfy Manufactory?](/products/manufactory/best-practices/what-is-observability/): Dive deeper into the definition and its specific relevance. * [Understanding structured events for observability in Tallyfy Manufactory](/products/manufactory/best-practices/understanding-structured-events/): Learn how to design effective event schemas. * [Implementing distributed tracing for event workflows with Tallyfy Manufactory](/products/manufactory/best-practices/implementing-distributed-tracing/): Visualize event lifecycles. * [Best practices for instrumenting applications for Tallyfy Manufactory](/products/manufactory/best-practices/instrumenting-applications-for-manufactory/): Send rich, contextual events. * [Analyzing events and deriving insights with Tallyfy Manufactory](/products/manufactory/best-practices/analyzing-events-and-deriving-insights/): Identify patterns and anomalies. * [Setting up effective alerts and SLOs[^2] with Tallyfy Manufactory event data](/products/manufactory/best-practices/setting-up-alerts-and-slos/): Define and monitor service level objectives. * [Effective event sampling strategies for Tallyfy Manufactory](/products/manufactory/best-practices/event-sampling-strategies/): Manage high-volume event streams. * [Adopting an observability culture with Tallyfy Manufactory](/products/manufactory/best-practices/adopting-observability-culture/): Foster data-driven decision-making. Each article builds on previous concepts to create a complete observability framework. Start with topics that address your immediate challenges. ## Getting started with observability Start small with your observability journey - pick one critical workflow or pressing problem. Focus on understanding that single aspect through Tallyfy Manufactory, then expand gradually. Success comes from developing an observability mindset: stay curious about system behavior and make data-driven improvements. --- *This guide shows you how to implement observability best practices with Tallyfy Manufactory. You'll learn to monitor and improve your event-driven systems effectively. These articles help both beginners and experienced users maximize Tallyfy Manufactory's capabilities.* [^1]: Typically implemented using correlation IDs that follow events across service boundaries [^2]: Service Level Objectives define measurable targets for system reliability and performance - **[Collector](https://tallyfy.com/products/manufactory/collector/)**: The Tallyfy Manufactory collector enables sending actor data and events through REST API websocket or CLI agent methods with data viewable in a custom interface after creating required schemas. The Tallyfy Manufactory collector allows you to send actor data and events, which can be viewed in our simple custom interface. Data ingestion can be made via a REST API, a websocket or a CLI agent. Please note, data ingestion cannot be done before creating both actors and events schemas. Please refer to [Implementation Guide](/products/manufactory/implementation/). The collector base URL is: `https://collector.tallyfy.com/` - **[Events](https://tallyfy.com/products/manufactory/events/)**: Tallyfy Manufactory allows you to design and build single event schemas for projects with careful planning of event properties being essential for successful implementation while requiring separate projects for multiple schemas. After creating a project in Tallyfy Manufactory, you can start designing and building the single events schema you want to use for this project. Planning which event properties you'll collect is crucial for a successful implementation. If you have multiple event schemas, you'll need to create multiple projects - we offer one schema per project. - **[Projects](https://tallyfy.com/products/manufactory/projects/)**: Tallyfy Manufactory requires creating individual projects with unique API keys and implementing both user and event schemas before sending data with separate projects needed for different platforms like iOS and Android applications. Creating a project is the first step to start using Tallyfy Manufactory. Each project in Manufactory has its own separate API key you'll use to send data. A project consists of two sections - a user schema and an event schema. Those schemas need to be implemented before sending events to a project. For example, if you have one iOS project and one Android project within your organization, you'll have your iOS app and your Android app send data to their respective project keys. - **[Implementation](https://tallyfy.com/products/manufactory/implementation/)**: A guide details the systematic approach to integrating Manufactory products through schema setup event tracking and user configuration while emphasizing proper planning for successful implementation. Implementing Tallyfy Manufactory within your product requires careful planning - but the process itself is straightforward when you have a solid strategy. Most teams complete their first integration in under a week[^1]. The implementation process consists of these key phases: [^1]: Assumes familiarity with REST APIs and OAuth flows. Complex integrations may take longer. - **[Triggers](https://tallyfy.com/products/manufactory/triggers/)**: Tallyfy Manufactory offers near real-time event-based triggers that respond to actor actions through configurable conditions and criteria enabling organizations to quickly act on incoming data patterns unlike many other systems. Tallyfy Manufactory supports near real-time triggers, sometimes called event-based triggers. This is unique - because many other systems don't give you the ability to act quickly on incoming data patterns. Event-based triggers fire based on actor actions. For example, a trigger could be set up to fire when an actor logs in or logs out, or when an actor takes a specific action within a system or application with or without a specific time-frame or even a specific occurrence count. A Manufactory trigger includes: - A condition is a specific rule or set of rules that must be met for the trigger to fire. - A criteria is a specific set of conditions that must be met for the trigger to be executed. Conditions can be based on various factors, like actor actions, system events or updating actor's attributes. For example, a condition could be set up to trigger a notification when a certain amount of time has passed since an actor last logged into an application, or when a specific event is stored. Criteria, on the other hand, are a set of conditions that must be met for the trigger to be executed. For example, a criteria could be set up to trigger an alert when a user logs in from an unrecognized device and is trying to access sensitive data. In this case, the criteria could include conditions like the user's location, the type of device being used, and the time of day. For additional information about triggers, contact us ![](https://screenshots.tallyfy.com/manufactory-triggers.png) ### Actors - **[Create actors schema](https://tallyfy.com/products/manufactory/actors/create_schema/)**: The POST /actors/schema endpoint enables creation of user schemas in Tallyfy Manufactory by specifying organization ID project ID attribute definitions and a unique identifier field with proper authentication headers. ## Create an actor schema via API You can create users schema in Tallyfy Manufactory using the endpoint `POST /actors/schema`. ### Authentication The following header is required for all API calls: - `X-Manufactory-Auth` - Manufactory access token ### Required keys - `org_id` (required) string - Manufactory org ID. - `project_id` (required) number - The project ID associated with this schema. - `attributes` (required) object - Pairs containing attribute name and the corresponding data type. A complete list of [valid data types](/products/manufactory/data-types/). - `unique_id` (required) string - The attribute that will be used as a unique ID for a actors profile[^1] to differentiate user profiles. ### Request example ```json { "org_id": "xyz", "unique_id": "email", "project_id": 12345, "attributes":{ "City": "TEXT", "Country": "TEXT", "Email": "TEXT", "Username": "TEXT" } } ``` ### Response example ```json { "message": "Actors schema created successfully" } ``` [^1]: Must be one of the defined attributes and serves as the primary identifier across all actor records - **[Delete actors schema](https://tallyfy.com/products/manufactory/actors/delete_schema/)**: The DELETE /actors/schema endpoint allows removal of actor schemas from Tallyfy Manufactory by providing organization ID project ID and authentication token. ## Delete an actor schema via API You can delete actors schema in Tallyfy Manufactory using the endpoint `DELETE /actors/schema/{org_id}/{project_id}`. ### Authentication The following header is required for all API calls: - `X-Manufactory-Auth` - Manufactory access token ### Required values - `org_id` (required) string - Manufactory org ID. - `project_id` (required) number - Manufactory project ID. - **[Get actors schema](https://tallyfy.com/products/manufactory/actors/get_schema/)**: The GET endpoint retrieves actor schema details including attribute definitions data types and unique identifiers for a specific project by providing organization ID project ID and authentication token. ## Get an actor schema via API You can get actors schema[^2] belonging to a specific project in Tallyfy Manufactory[^1] using the endpoint `GET /actors/schema/{org_id}/{project_id}`. ### Authentication The following header is required for all API calls: - `X-Manufactory-Auth` - Manufactory access token ### Required values - `org_id` (required) string - Manufactory org ID. - `project_id` (required) number - Manufactory project ID. ### Response example ```json { "attributes": [ { "name": "city", "display_name": "City", "data_type": "text" }, { "name": "country", "display_name": "Country", "data_type": "text" }, { "name": "email", "display_name": "Email", "data_type": "text" }, { "name": "username", "display_name": "Username", "data_type": "text" } ], "org_id": "xyz", "unique_id": "email", "project_id": 12345 } ``` [^1]: Tallyfy's manufacturing workflow automation platform with custom data structures and actors [^2]: Data structure defining the attributes and properties of workflow participants in a project ### Best practices - **[Analyzing events and deriving insights](https://tallyfy.com/products/manufactory/best-practices/analyzing-events-and-deriving-insights/)**: Effective event analysis in Tallyfy Manufactory transforms raw data into actionable insights through an iterative core analysis loop of observing issues and formulating hypotheses and testing them by filtering and grouping event data to answer questions about system behavior and performance and failures which ultimately drives improvements in system design and workflow optimization and actor logic. Once your applications are instrumented to send rich, structured events to Tallyfy Manufactory, the next step is to transform that raw data into actionable insights. Effective event analysis allows you to understand the behavior of your event-driven systems, troubleshoot issues, and continuously improve your processes. ## The goal of event analysis in Tallyfy Manufactory Event analysis is more than just looking at logs or event streams. It's an active process of interrogating your event data to answer specific questions about your workflows that involve Tallyfy Manufactory. The primary goals are to understand: * **What happened?** Reconstruct sequences of events and actions. * **Why did it happen?** Identify root causes of failures or unexpected behavior. * **What is the impact?** Assess the scope and severity of issues, or measure the success of your processes. While Tallyfy Manufactory is an event ingestion and lifecycle engine, it may offer features for basic event searching and viewing. For deeper analysis, you might export event data from Manufactory (if available) or ensure events are also sent to dedicated observability or analytics platforms[^1] where more sophisticated querying can occur. ## The core analysis loop for event data A systematic approach to analyzing event data, often called the "core analysis loop," can be highly effective, especially when investigating issues related to Tallyfy Manufactory event processing: 1. **Observe:** Start with a high-level view. This could be an alert, a customer report, or a general question about an event flow managed by Manufactory (e.g., "Why did event processing for Project X spike in failures last night?"). 2. **Orient:** Formulate a hypothesis. Based on your understanding of the system and the initial observation, what do you suspect might be happening with the events in Manufactory? (e.g., "I suspect a specific actor in Project X is failing due to a malformed payload.") 3. **Decide & Act:** Test your hypothesis by querying and filtering the event data. This might involve: * Filtering events by time ranges, specific event types (e.g., `OrderFailedToProcess`), or particular field values (`user_id = '123'`, `manufactory_actor_status = 'error'`). * Grouping events by dimensions to see distributions (e.g., group by `event_source` to see event volumes from different systems sending data to Manufactory, or group by `error_code` for events processed by a Manufactory actor). * Aggregating data if your analysis tool supports it (e.g., counting events, calculating average processing times if such data is part of your events or provided by Manufactory). 4. **Learn & Iterate:** Examine the results of your query. Does it confirm or refute your hypothesis? Does it provide a clear answer or lead to new, more specific questions? Refine your query or hypothesis and repeat the loop. This iterative process of questioning and refining helps you drill down from a general problem to a specific root cause within your event streams, including those managed by Tallyfy Manufactory. ### How the analysis loop works This diagram shows the cyclical nature of event analysis - moving from observation through hypothesis testing to actionable insights. [Diagram removed for brevity] **What to notice:** - The process is iterative - you may need several cycles to reach the root cause - Each "No" result from hypothesis testing leads to refinement, not failure - Partial confirmations generate new, more specific questions that restart the loop ## Common analytical questions for Tallyfy Manufactory users Here are some typical questions you might seek to answer by analyzing event data related to Tallyfy Manufactory: * **Event Volume & Flow:** * "How many `NewUserSignup` events did Tallyfy Manufactory ingest from our website yesterday?" * "What is the distribution of event sources sending data to our `OrderProcessing` Manufactory project?" * "Did we see an unexpected spike or drop in events for the `InventoryUpdate` workflow that Manufactory handles?" * **Event Success & Failure within Manufactory:** * "What percentage of events processed by Manufactory actor `PaymentGatewayConnector` are resulting in a 'failure' status?" * "What are the most common error messages or codes for events that failed processing within a specific Manufactory trigger?" * "Are events from a particular `customer_id` experiencing a higher failure rate within our Manufactory invoicing project?" * **Performance & Latency (if events contain timing data or Manufactory provides it):** * "What is the average time it takes for an event to be processed from ingestion by Manufactory to the completion of its final triggered actor in workflow Z?" * "Are there specific Manufactory actors or routing rules within our projects that appear to be introducing significant latency?" * **Specific Event Investigation:** * "Show me all events and their states related to `order_id: ORD-12345` that were handled by any Tallyfy Manufactory project." * "What was the exact payload of `event_id: evt-abcdef123456` when it was ingested by Manufactory, and which actors did it trigger?" ## Techniques for analyzing event data from Manufactory To answer the questions above, you'll employ various analytical techniques on your event data (whether directly in Manufactory if it has such tools, or in an external platform): * **Filtering:** This is fundamental. Narrow down your dataset to only the events relevant to your investigation. For example, in a system analyzing Manufactory events, you might filter for `event_type = "ShipmentNotificationFailed" AND manufactory_project_id = "LogisticsUpdates"`. * **Grouping (and Aggregating):** Group events by common attributes to see patterns and distributions. Then, aggregate values within those groups. For example, `GROUP BY manufactory_actor_name, COUNT(event_id) WHERE status = 'ERROR'` would show you which actors are failing most often. * **Time-series Analysis:** Look at how event metrics (like counts or failure rates) change over time. Plotting the number of failed events processed by a Manufactory project per hour can reveal trends or correlate failures with other system activities. * **Correlation:** Identify potential relationships between different event attributes or between different types of events. For instance, "Do `PaymentProcessed` events (potentially from a Manufactory actor) take longer when the `payment_gateway_region` attribute is 'EU' compared to 'US'?" * **Anomaly Detection (Conceptual)[^2]:** This involves identifying unusual patterns or significant deviations from normal behavior in your event streams. While complex anomaly detection might require specialized tools, even simple visual inspection of time-series graphs of Manufactory event volumes can reveal anomalies. ## Using Tallyfy Manufactory's features for analysis How you analyze event data will depend on Tallyfy Manufactory's specific capabilities. Consider: * **Built-in Querying/Searching:** Does Manufactory offer an interface to search or filter ingested events based on their attributes directly within its UI? * **Dashboards and Visualizations:** Does Manufactory provide any out-of-the-box dashboards or visualizations for key event metrics (e.g., event throughput, error rates for projects or actors)? * **Data Export:** Can event data (or summaries) be exported from Manufactory for analysis in external tools like business intelligence platforms, data warehouses, or using custom scripts? * **Logs and Audit Trails:** How can logs or audit trails generated by Manufactory itself be used to complement event data during an investigation? Understanding these features will help you determine the most efficient way to analyze data directly related to Manufactory's operations. ## From analysis to action The ultimate goal of analyzing Tallyfy Manufactory event data is to drive improvements. Insights gained can lead to: * **Better System Design:** Identifying problematic event schemas or inefficient workflow designs. * **Optimized Workflows:** Streamlining processes that involve Manufactory based on performance data. * **Enhanced Actor Logic:** Refining the logic within Manufactory actors to handle edge cases or improve efficiency. * **More Effective Alerts and SLOs:** Using historical event analysis to set realistic and meaningful alerts (as discussed in a subsequent article). * **Improved Support:** Providing support teams with better tools and understanding to resolve issues related to event-driven processes managed by Manufactory. ## Developing your analytical skills Becoming proficient at analyzing event data from Tallyfy Manufactory is a skill that develops over time: * **Start with simple questions** and gradually tackle more complex analytical tasks. * **Practice the core analysis loop** regularly, even for non-critical investigations, to build intuition. * **Share your findings and techniques** with your team to foster collective learning and discover new ways to use Manufactory data. By actively engaging with your event data, you can unlock powerful insights into the health and performance of the critical business processes managed by Tallyfy Manufactory. [^1]: Common platforms include Datadog, New Relic, Splunk, or Elastic Stack for event stream analysis [^2]: Statistical methods like z-scores or isolation forests can identify outliers in event patterns - **[Adopting an observability culture](https://tallyfy.com/products/manufactory/best-practices/adopting-observability-culture/)**: Building an observability culture for Tallyfy Manufactory requires fostering team-wide curiosity and shared ownership while integrating data-driven practices into development workflows and using blameless incident reviews to continuously improve event instrumentation and system understanding. Using Tallyfy Manufactory effectively for deep insights into your event-driven systems goes beyond just implementing the right tools and instrumentation. It requires fostering an **observability culture** within your teams - a way of thinking and working that prioritizes understanding system behavior through data. ## Observability is more than just tools While having well-instrumented applications sending rich event data to Tallyfy Manufactory is essential, true observability is achieved when your teams embrace a cultural shift. This involves: * **Curiosity:** Encouraging engineers and other stakeholders to proactively ask questions about how their systems and Tallyfy Manufactory workflows are behaving, rather than just reacting to problems. * **Shared Ownership:** Recognizing that understanding system performance and reliability, including event processing through Manufactory, is everyone's responsibility, not just a dedicated operations team. * **Blamelessness:** When incidents occur, focusing on learning what happened and how to improve (including improving Manufactory configurations or event instrumentation), rather than assigning blame. * **Data-Driven Decision-Making:** Using insights gleaned from Tallyfy Manufactory event data and other observability sources to inform design choices, prioritize improvements, and validate changes. ## Observability-driven development with Manufactory Observability-Driven Development (ODD) is one of the most impactful ways to embed observability into your culture. This practice is especially valuable for services that interact with or are orchestrated by Tallyfy Manufactory: * **Think About Observability from the Start:** When designing a new feature that involves events passing through Tallyfy Manufactory, ask critical questions upfront: "How will we observe this new workflow?" "What specific events does Manufactory need to see, and with what attributes, for us to understand its behavior?" "What potential failure points exist in this Manufactory project, and how will our events help us diagnose them?" * **Instrument as You Code:** Make emitting detailed, contextual events (destined for or generated by Manufactory) a natural part of the development process, not an afterthought. * **Use Manufactory Data During Development and Testing:** Observe event flows and actor behaviors in pre-production environments. This can help catch integration issues with Manufactory or flawed logic before it reaches production. * **Ship with Confidence:** Knowing you have the visibility through Tallyfy Manufactory (and associated tools) to understand how new features are performing in production reduces deployment anxiety and speeds up feedback loops. ## Fostering a data-driven culture with Tallyfy Manufactory To make decisions based on data from Tallyfy Manufactory, that data needs to be accessible and its exploration encouraged: * **Democratize Access to Manufactory Data:** Where appropriate and feasible (considering data sensitivity and tool capabilities), make insights from Tallyfy Manufactory event data available not just to operations engineers, but also to developers, product managers, and support teams. This might involve dashboards, query tools, or regular reports derived from Manufactory data. * **Encourage Exploration:** Create an environment where teams feel empowered and psychologically safe to explore Tallyfy Manufactory event data. They should be able to ask ad-hoc questions without fear of "breaking something" or inadvertently running up excessive costs (within reasonable, guided bounds). * **Regularly Review Manufactory Event Patterns:** Incorporate the analysis of event data from Tallyfy Manufactory into regular team meetings, sprint reviews, or incident retrospectives. Discuss questions like: "What did we learn from our Manufactory event flows this past week?" or "Are there any surprising or anomalous event patterns emerging in our Manufactory projects?" ## Shared ownership and collaboration around Tallyfy Manufactory events Observability thrives when silos are broken down and different teams collaborate using shared data, such as that flowing through Tallyfy Manufactory: * **Developers Owning Their Code in Production:** Using event data (including data on how their services interact with Manufactory) to understand the real-world impact and performance of their code. * **Support Teams Using Manufactory Insights:** Empowering support personnel to troubleshoot customer issues more effectively by examining relevant event flows and statuses within Tallyfy Manufactory (or tools that display its data). * **Product Teams Using Manufactory Data for Feature Validation:** Understanding how features that trigger, or are triggered by, Tallyfy Manufactory events are being used by customers, and identifying areas for improvement. * **A Common Language:** Tallyfy Manufactory event data can become a shared language that helps different teams (development, operations, product, support) communicate more effectively about system behavior. ## Blameless learning from incidents involving Tallyfy Manufactory When an incident occurs involving a workflow managed or monitored by Tallyfy Manufactory, the cultural approach is critical: * **Focus on Learning, Not Blame:** The primary goal of a post-incident review should be to understand the sequence of events (using Manufactory data, traces, etc.) and identify systemic improvements, not to find individuals at fault. * **Reconstruct What Happened:** Use event data from Tallyfy Manufactory, distributed traces, logs, and metrics to build a clear timeline of the incident. * **Ask Improvement-Oriented Questions:** "How could our event instrumentation for Manufactory have helped us detect this issue sooner?" "How could data from Manufactory have allowed us to diagnose the root cause faster?" "What changes to our Manufactory project configurations or actor logic could prevent this in the future?" * **Feed Learnings Back:** Ensure that insights from incidents lead to concrete actions, such as improving event schemas, enhancing instrumentation for Manufactory, refining actor logic, or updating alert configurations. ## Practical steps to cultivate an observability culture for Manufactory Building this culture takes deliberate effort: * **Leadership Buy-in and Advocacy:** Management must champion the importance of observability and allocate the necessary resources (time, tools, training) for initiatives related to Tallyfy Manufactory. * **Training and Enablement:** Provide training on how to effectively instrument applications for Tallyfy Manufactory, how to query and analyze its event data, and how to interpret distributed traces that include Manufactory spans. * **Internal Champions or an "Observability Guild":** Identify and empower enthusiasts within your organization to share best practices, help onboard other teams to using Tallyfy Manufactory for observability, and drive continuous improvement. * **Show, Don't Just Tell:** Demonstrate the value of Tallyfy Manufactory event analysis by using it to solve real, painful problems and then widely sharing those success stories. * **Integrate with Existing Workflows:** Add observability considerations into your existing processes. For example, include a checklist item in code reviews: "Is this new service/feature adequately instrumented to send relevant events to/from Manufactory?" * **Start Small and Iterate:** Don't attempt to transform your entire organization's culture overnight. Pick a key workflow involving Tallyfy Manufactory, establish good observability practices for it, demonstrate the benefits, and then expand from there. ## Measuring the impact of your observability culture While cultural change can be hard to quantify precisely, you can look for indicators of progress: * **Qualitative Measures:** Increased confidence among teams when deploying changes that interact with Manufactory, better collaboration between developers and operations, more proactive problem-solving discussions centered around Manufactory event data. * **Quantitative Measures (often influenced by multiple factors, but indicative):** * Reduction in Mean Time To Resolution (MTTR)[^1] for incidents involving Tallyfy Manufactory workflows. * Improved reliability (higher [SLO[^2]](/products/manufactory/best-practices/setting-up-alerts-and-slos/) compliance) for services and processes integrated with Manufactory. * Potentially faster development cycles for features that use Tallyfy Manufactory, due to quicker debugging and validation. * Increased usage of Tallyfy Manufactory data by diverse teams (not just operations) for decision-making. ## Continuous improvement An observability culture, much like the Tallyfy Manufactory system itself and the applications it integrates with, is never truly "done." It requires continuous nurturing and improvement. Regularly solicit feedback on how Tallyfy Manufactory is being utilized for observability within your organization and actively look for opportunities to refine your tools, processes, and skills. [^1]: Average time from incident detection to full resolution, key metric for operational efficiency [^2]: Service Level Objective - measurable reliability targets like uptime or response time goals - **[Effective event sampling strategies](https://tallyfy.com/products/manufactory/best-practices/event-sampling-strategies/)**: Event sampling strategies help manage high-volume event streams in Tallyfy Manufactory by reducing data costs and improving performance through techniques like fixed-rate sampling or content-based sampling while prioritizing critical events such as errors and business transactions and propagating sample rate metadata for accurate weighted analysis. As your systems scale, the volume of events generated can become substantial. While Tallyfy Manufactory is designed to handle significant event loads, sending, storing, and processing every single event might become impractical or cost-prohibitive, both for Manufactory itself and for any downstream observability or analytics systems. Event sampling offers a way to manage this volume while still retaining the crucial data needed for effective observability. ## Why consider sampling for events sent to Tallyfy Manufactory? Implementing an event sampling strategy before events reach Tallyfy Manufactory, or for data exported from Manufactory, can offer several benefits: * **Volume and Cost Reduction:** High-traffic applications can generate millions or even billions of events. Storing and processing every single one within Tallyfy Manufactory and any connected analytics platforms can lead to significant infrastructure and vendor costs. * **Performance Optimization:** Ingesting, indexing, and analyzing massive, unsampled event streams can potentially impact the performance of Tallyfy Manufactory or the tools you use to query its data. * **Signal vs. Noise Enhancement:** Not all events are equally valuable for observability. Many events are repetitive and indicate successful, normal operations. While some record of these is important, keeping every single one might not be necessary if a statistically representative sample is retained. Sampling can help focus on the more interesting or anomalous events. The primary goal of sampling events related to Tallyfy Manufactory is to reduce the overall data volume without losing the ability to debug issues, understand system behavior, and meet your [Service Level Objectives (SLOs)](/products/manufactory/best-practices/setting-up-alerts-and-slos/) for processes involving Manufactory. ## Key sampling concepts Before diving into specific strategies, let's define some core sampling terms: * **Sample Rate:** The proportion of events that are kept and processed versus discarded. For example, a sample rate of 1:100 (or 1%) means one event is kept for every 100 generated. * **Head-based Sampling:** The decision to keep or drop an event (or an entire trace) is made at the beginning of its lifecycle, typically based on static attributes known at that time. * **Tail-based Sampling:** The decision to sample is deferred until after an event or an entire trace has completed. This allows sampling decisions to be based on the outcome of the operation (e.g., whether it was an error, or if it exceeded a latency threshold). * **Dynamic Sampling:** The sample rate is not fixed but adjusts automatically based on factors like current traffic volume or specific characteristics of the events. ## Common sampling strategies relevant to Tallyfy Manufactory Here are a few sampling strategies that can be particularly relevant when dealing with events sent to or processed by Tallyfy Manufactory: * **Constant Probability (Fixed-Rate) Sampling:** * **How it works:** You define a fixed rate (e.g., keep 1 out of every N events) that applies to all events being sent to Manufactory, or to a specific category of events. * **Pros:** Very simple to implement in your event-producing applications. * **Cons:** If the rate is too low (e.g., sampling 1 in 1000), you risk missing rare but critical events, like infrequent error types within a Manufactory workflow. High-volume, low-importance event types can also disproportionately drown out low-volume, high-importance events in your sampled dataset. * **Per-Key (Content-Based) Sampling:** * **How it works:** You define different sample rates based on the values of one or more attributes within the event. For example, you could sample based on `event_type`, `customer_id`, or an `error_status` field that indicates if a previous step related to a Manufactory process failed. * **Example for Manufactory:** Always keep 100% of `PaymentTransactionFailed` events that are routed through a Manufactory project, but sample only 5% of `UserActivityHeartbeat` events that Manufactory might also ingest for auditing. * **Pros:** Ensures that events you deem critical are always captured. Allows you to balance representation across different types or priorities of events that interact with Manufactory. * **Cons:** Requires careful thought to define the right keys and their respective rates. Managing a large number of keys can become complex. * **Target Rate Sampling (Adaptive Sampling):** * **How it works:** Instead of a fixed percentage, you aim to send a target number of events per second (or minute) to Tallyfy Manufactory, either overall or for specific keys. The actual sampling percentage dynamically adjusts based on the incoming event volume. * **Example:** If your `OrderCreated` events (processed by a Manufactory project) suddenly spike from 10/second to 1000/second, an adaptive sampler might automatically reduce the sampling percentage from 100% down to 1% to maintain a target ingested rate of, say, 10 `OrderCreated` events/second in Manufactory or your analytics tool. * **Pros:** Helps protect Tallyfy Manufactory and downstream analysis systems from being overwhelmed by traffic spikes. Provides a more consistent volume of data for analysis, which can simplify capacity planning for your observability infrastructure. * **Cons:** Can be more complex to implement correctly, especially ensuring that the `sample_rate` metadata is accurately calculated and propagated for weighted analysis later on. ## Best practices for sampling events sent to Tallyfy Manufactory When implementing sampling for events that will be processed or observed via Tallyfy Manufactory: * **Prioritize Keeping Critical Events:** * Always aim to keep 100% (or a very high percentage) of events indicating errors or failures, especially those related directly to Tallyfy Manufactory's processing (e.g., an actor failing, a routing rule mismatch). * Preserve events for critical business transactions (e.g., order completions, payment processing steps that involve Manufactory). * Consider higher sampling rates for events from key customers or high-value workflows managed by Manufactory. * **Understand the Purpose of Events in Manufactory:** * If Tallyfy Manufactory *requires* seeing every single event for a specific trigger or project to function correctly (e.g., for accurate state management or sequencing), then sampling those events *before* they reach Manufactory is likely not an option. In such cases, sampling might only be viable for data *exported from* Manufactory for long-term storage or analysis. * If Manufactory is primarily used for observation, or for triggering less critical, idempotent downstream actions, then sampling upstream events might be more feasible. * **Propagate Sampling Decisions with Traces:** * If an event is part of a [distributed trace](/products/manufactory/best-practices/implementing-distributed-tracing/), and a head-based sampling decision has already been made to keep that trace, ensure all subsequent events belonging to that trace (including any sent to or generated by Tallyfy Manufactory) are also kept. The trace context should carry the sampling decision. * Crucially, **include the `sample_rate` as an attribute in the event data** sent to Tallyfy Manufactory (and any other observability backend). This allows analysis tools to correctly reconstruct original event volumes and perform weighted calculations for accurate metrics. * **Start Simple and Iterate:** You don't need a perfect, complex sampling strategy from day one. Begin with a basic approach (like fixed-rate for non-critical events, and 100% for errors) and refine it as you understand your event volumes and the specific insights you need from Manufactory data. * **Monitor Your Sampling Effectiveness:** Regularly ask: Are we still able to debug issues effectively with the sampled data? Are we missing important trends or anomalies in our Tallyfy Manufactory event flows because of sampling? ## How Tallyfy Manufactory might interact with sampled data Consider these aspects regarding Tallyfy Manufactory itself: * **Awareness of `sample_rate`:** If events ingested by Manufactory include a `sample_rate` attribute, can Manufactory or any tools analyzing its data (or data exported from it) use this for weighted analysis to reconstruct accurate counts or metrics? * **Internal Sampling (Hypothetical):** Does Tallyfy Manufactory offer any built-in sampling capabilities for the events it processes, or for the data it archives or exports for long-term analysis? * **Impact on Triggers/Actors:** If upstream events are heavily sampled before they reach Tallyfy Manufactory, how does this affect the reliability or completeness of data for Manufactory triggers or actors that depend on those events? ## Balancing cost, performance, and visibility Event sampling is ultimately a series of trade-offs. The primary goal is to find a strategy that significantly reduces the data load on Tallyfy Manufactory and other systems without critically impairing your ability to observe, understand, and troubleshoot your event-driven workflows. This often means employing a hybrid approach: perhaps aggressively sampling high-volume, low-criticality events while ensuring complete capture of errors and events from vital business processes that Tallyfy Manufactory handles. Regularly review and adjust your sampling strategy as your system, event volumes, and observability needs evolve. - **[Implementing distributed tracing for event workflows](https://tallyfy.com/products/manufactory/best-practices/implementing-distributed-tracing/)**: Distributed tracing tracks the progression of events through complex microservices architectures by creating unique identifiers that link related operations across multiple systems enabling complete visualization of event-driven workflows and helping identify bottlenecks and failures in systems like Tallyfy Manufactory. In complex event-driven architectures, a single initial event can trigger a cascade of actions across multiple services and components. Tallyfy Manufactory often plays a key role in these flows, ingesting events, routing them, or triggering specific actors. Distributed tracing provides a way to visualize and understand these intricate journeys. ## What is distributed tracing? Distributed tracing is a technique used to monitor and profile applications, especially those built using a microservices architecture. It tracks the progression of a single request or, in our context, a single initiating event, as it moves through various services or processing stages. Imagine you're sending a package. Distributed tracing is like having a master tracking number that allows you to see every hub your package passes through, how long it stayed at each point, and its final delivery status. This gives you a complete picture of the journey. Key components of distributed tracing include: * **Trace:** Represents the entire end-to-end journey of a request or event. * **Span:** Represents a single, named, timed operation within a trace. A trace is made up of one or more spans. For example, an event being ingested by Tallyfy Manufactory could be one span, and a Manufactory actor processing that event could be another span within the same trace. * **Trace ID:** A unique identifier shared by all spans within a single trace. * **Span ID:** A unique identifier for an individual span. * **Parent Span ID:** An identifier that links a span to its parent span, creating a chronological and hierarchical relationship. These relationships are often visualized using waterfall diagrams[^2], which clearly show the sequence, duration, and dependencies of operations within a trace. ## Why distributed tracing is valuable for Tallyfy Manufactory For Tallyfy Manufactory users, distributed tracing offers several significant benefits when observing event-driven workflows: * **Visualizing end-to-end event flows:** You can see how an event originating from one system travels, gets ingested and processed by Tallyfy Manufactory, and then potentially triggers various [actors](/products/manufactory/actors/) or other downstream systems. This holistic view is invaluable. * **Pinpointing bottlenecks and failures:** If an event-driven process is slow or failing, a trace can quickly show which specific service, Manufactory project, or actor is causing the delay or error. * **Debugging complex interactions:** Event-driven systems often involve asynchronous operations and intricate inter-service communication. Tracing helps make sense of these by showing the exact path and timing of related events and actions, including those managed by Manufactory. * **Understanding event lineage:** Easily trace an event from its initial creation, through its handling by Tallyfy Manufactory, to its ultimate outcome or impact on other systems. ## Core components of a trace in the context of Manufactory events When an event processed by or interacting with Tallyfy Manufactory is part of a distributed trace, its span data should include: * **Trace ID:** The unique identifier for the overall workflow or transaction this event belongs to (e.g., a customer placing an online order might have a single trace ID covering all related events and service calls). * **Span ID:** A unique ID for this specific processing step (e.g., `Manufactory-Ingest-OrderCreatedEvent`, `Manufactory-Actor-DispatchNotification`). * **Parent Span ID:** If this Manufactory-related span was triggered by a previous operation (e.g., an API call that emitted an event to Manufactory), this ID links it back to that parent operation. * **Service Name / Actor Name:** Clearly identifies the system or specific Tallyfy Manufactory component (like a project or actor) that performed the work represented by this span. * **Timestamps and Durations:** Essential for understanding when the operation started and how long it took, which is critical for performance analysis. ## Best practices for implementing tracing with Manufactory To effectively trace event workflows involving Tallyfy Manufactory, consider these best practices: * **Context Propagation:** This is the most crucial aspect. The `Trace ID` and `Parent Span ID` (and other relevant trace context like sampling decisions) must be consistently passed along with events. This includes: * When an event is initially sent to Tallyfy Manufactory. * When Tallyfy Manufactory itself emits new events or triggers downstream actors or external systems. * Utilize standard propagation formats like W3C Trace Context or B3[^1], typically embedded in HTTP headers (for REST API interactions with Manufactory) or message metadata (for message queue interactions). * **Instrumenting Services Interacting with Manufactory:** * Services that send events to Tallyfy Manufactory should either start a new trace (if they are the originators) or continue an existing trace by creating a new child span. * Actors within Tallyfy Manufactory, or external systems triggered by Manufactory events, should create their own child spans, linking back to the trace context of the event that triggered them. * **Naming Spans Effectively:** Use clear, descriptive, and consistent names for your spans. This makes traces much easier to understand. Examples for Manufactory-related spans: * `Manufactory::EventIngest::OrderCreated` * `Manufactory::Project::ProcessNewUser::RouteEvent` * `Manufactory::Actor::SendWelcomeEmail` * **Adding Relevant Attributes (Tags) to Spans:** Enrich your spans with key-value pairs (attributes or tags) that provide context. For Manufactory events, this could include: * Event-specific data: `event_type`, `event_id`, relevant business identifiers like `order_id` or `user_id`. * Manufactory-specific identifiers: `manufactory.project_id`, `manufactory.trigger_id`, `manufactory.actor_id`. * Technical details: `http.method`, `status_code` (for API interactions with Manufactory). ## Conceptual example: Tracing an event through Tallyfy Manufactory Let's imagine a new customer completes a signup form on your application: 1. **Span A (Root or Child of API Span):** Your `UserAccountService` receives the signup request. It creates a span named `CreateUserAccount`. As part of this, it generates a `UserSignedUp` event. 2. The `UserAccountService` sends the `UserSignedUp` event to a Tallyfy Manufactory endpoint, ensuring the `Trace ID` from Span A and Span A's ID (as Parent Span ID) are propagated with the event. 3. **Span B (Child of Span A):** Tallyfy Manufactory ingests the `UserSignedUp` event. A span named `Manufactory::EventIngest::UserSignedUp` is created (conceptually, by your instrumentation or how Manufactory itself might participate in tracing). 4. **Span C (Child of Span B):** A Manufactory [project](/products/manufactory/projects/) configured for `UserSignedUp` events processes it. A span named `Manufactory::Project::Onboarding::ProcessUserSignedUp` might represent this routing/evaluation logic. 5. **Span D (Child of Span C):** The project triggers a `WelcomeEmailActor` within Manufactory. This actor creates a span `Manufactory::Actor::WelcomeEmailActor::SendEmail`. 6. **Span E (Child of Span C):** The project also triggers a `ProvisionTrialAccessActor`. This actor creates a span `Manufactory::Actor::ProvisionTrial::GrantAccess`. If the customer later reports not receiving a welcome email, this distributed trace would immediately show whether Manufactory received the initial event, if it triggered the `WelcomeEmailActor`, and potentially if that actor encountered an error. This significantly speeds up troubleshooting. ### Visualizing the trace flow This diagram shows how trace context propagates through the entire event processing pipeline. [Diagram removed for brevity] **Diagram description:** This diagram visualizes how a trace ID propagates through an event-driven system, starting from a user login request through authentication services to Manufactory's event processing pipeline. The trace ID (xyz123) remains consistent across all components, enabling end-to-end monitoring as the event triggers both a webhook endpoint and a processing task in parallel. **What to notice:** - **Trace ID propagation** - The same Trace ID (xyz123) flows through all services, linking every operation to the original request - **Parent-child relationships** - Each span references its parent, creating a clear hierarchy: A spawns B, B spawns C, and C spawns both D and E in parallel - **Parallel execution visibility** - The diagram clearly shows how Manufactory can trigger multiple actors simultaneously, with both operations tracked as separate child spans ## Tools and considerations It's important to note that while Tallyfy Manufactory processes events that are part of a distributed trace, it isn't typically a distributed tracing backend itself. You would generally use a dedicated tracing system (open source options like Jaeger or Zipkin, or various commercial observability platforms) to collect, store, and visualize these traces. Tallyfy Manufactory's crucial role in this ecosystem is to faithfully carry forward any trace context it receives with an event and to allow its own operations (like actor executions) to be instrumented as part of that broader trace. Your instrumentation within services sending events to Manufactory, and within actors or services triggered by Manufactory, is key to achieving this end-to-end visibility. [^1]: Industry-standard formats for trace context propagation across distributed systems [^2]: Visual representation showing sequential operations as cascading horizontal bars with timing - **[Setting up effective alerts and SLOs](https://tallyfy.com/products/manufactory/best-practices/setting-up-alerts-and-slos/)**: SLOs provide a user-centric framework for creating actionable alerts by measuring error budget burn rates instead of relying on noisy traditional cause-based alerts that often lead to alert fatigue in event-driven systems. Effective alerting is crucial for maintaining the reliability of your event-driven systems, especially those orchestrated or monitored by Tallyfy Manufactory. However, traditional alerting methods often lead to noise and fatigue. This article introduces Service Level Objectives (SLOs) as a stronger framework for creating actionable alerts based on your Tallyfy Manufactory event data. ## Why traditional alerting falls short for event-driven systems Many teams struggle with alerts that are either too noisy (triggering for non-issues) or too quiet (missing real problems). This is often because traditional alerts are: * **Cause-based:** They trigger on specific technical conditions (e.g., "CPU utilization over 80%," "Queue length exceeds 1000 messages"). While sometimes useful, these don't always correlate directly with user-facing problems or issues in Tallyfy Manufactory event processing. * **Reliant on static thresholds:** Event flows can be highly dynamic. A fixed threshold that makes sense during peak load might be too sensitive during quiet periods, leading to false alarms related to Manufactory workflows. * **Prone to alert fatigue:** When engineers are constantly bombarded with unactionable alerts, they start to ignore them, increasing the risk of missing genuine incidents, including those affecting Tallyfy Manufactory. For event-driven systems where Tallyfy Manufactory manages critical event lifecycles, a more nuanced approach is needed to ensure alerts are both meaningful and actionable. ## Service Level Objectives and error budgets Service Level Objectives (SLOs) and error budgets provide a user-centric way to define and measure reliability. * **Service Level Indicator (SLI):** A quantifiable measure of performance or reliability for a specific aspect of your service. For Tallyfy Manufactory, an SLI could be the percentage of events successfully ingested, the latency of an event through a Manufactory [project](/products/manufactory/projects/), or the success rate of a specific Manufactory [actor](/products/manufactory/actors/). * **Service Level Objective (SLO):** A target value or range for an SLI over a defined period. This is your internal goal. For example: "99.9% of `OrderConfirmation` events sent to Tallyfy Manufactory will be successfully ingested and trigger the `NotificationActor` within 5 seconds, measured over a rolling 30-day window." * **Error Budget:** The amount of allowable failure before your SLO is breached (calculated as 100% - SLO target). If your SLO is 99.9%, your error budget is 0.1%. This budget represents the acceptable number of bad events or unacceptable latencies before you consider the service to be underperforming from a user perspective. SLOs shift the focus from arbitrary system metrics to what truly matters: the experience of your users and the success of critical business processes facilitated by Tallyfy Manufactory. ## Defining meaningful SLIs and SLOs for Tallyfy Manufactory To create effective SLOs for workflows involving Tallyfy Manufactory, first identify the most critical event flows or user journeys that Manufactory supports. Consider Manufactory's role in these flows: * **Event Ingestion:** Is successful and timely event ingestion by Manufactory critical? An SLI could be the percentage of events successfully accepted by Manufactory's API or collectors. * **Event Processing/Routing:** Does Manufactory route events to different actors or projects based on complex rules? An SLI could measure the success rate of these routing decisions or the latency introduced. * **Actor Performance:** Are specific actors within Manufactory performing critical business logic? SLIs can target their success rate or execution duration. * **End-to-End Event Lifecycle:** For a complete business process where Tallyfy Manufactory is a key component (e.g., processing an e-commerce order from creation to shipment notification), an SLI might measure the overall success rate or duration of that entire flow, with Manufactory's contribution being a part of it. **Examples of SLIs for Tallyfy Manufactory:** * `(Number of successfully ingested events by Manufactory endpoint X) / (Total events attempted to be sent to endpoint X)` * `(Number of events correctly routed by Manufactory project 'UserOnboarding') / (Total events processed by project 'UserOnboarding')` * `(Number of Manufactory actor 'InventoryUpdateActor' executions completed under 300ms) / (Total executions of actor 'InventoryUpdateActor')` When setting SLO targets, be realistic. Start with achievable goals based on current performance and gradually tighten them as you improve your systems and processes around Manufactory. ## Alerting on SLOs: Burn rate and symptom-based alerting Instead of alerting on myriad potential causes, **alert on symptoms** that indicate your SLO is at risk. The most effective way to do this is by monitoring your **error budget burn rate[^1]**. * **Error Budget Burn Rate:** This measures how quickly your allowed error budget is being consumed. If you have a 0.1% error budget for 30 days, and you consume 0.05% in the first day, your burn rate is high. * **Setting Alert Thresholds:** Configure alerts to trigger when, if the current error budget burn rate continues, your entire error budget will be exhausted within a critical timeframe (e.g., alert if you're on track to burn your monthly budget in the next 4 hours, or in the next 24 hours). This approach ensures alerts are: * **Actionable:** A rapidly burning error budget for a Manufactory process signifies a real or imminent problem impacting your defined objectives. * **User-focused:** Alerts are tied directly to the reliability targets you've set for workflows involving Tallyfy Manufactory. ## SLO alerting flow visualization This diagram shows how SLI measurements flow through error budget calculations to trigger different alert severities based on burn rates. [Diagram removed for brevity] **What to notice:** - **Two-tier alerting:** Fast burns (4h) trigger critical pages while slower burns (24h) generate warnings, balancing urgency with noise reduction - **Feedback loop:** Alerts lead to investigation and fixes that feed back into the system, creating continuous improvement - **Budget-based decisions:** The system only alerts when your error budget is actually being consumed at concerning rates, not on arbitrary thresholds ## How Tallyfy Manufactory data supports SLOs and alerting Event data processed by or originating from Tallyfy Manufactory is key to implementing SLO-based alerting: * **Event Status:** Events often contain status fields (e.g., `success`, `failure`, `error_code`). Manufactory itself might add status information regarding its own processing (e.g., `ingestion_successful`, `actor_execution_failed`). This is vital for distinguishing "good" events from "bad" events for your SLIs. * **Event Counts:** To calculate SLIs like success rates, you need accurate counts of total relevant events and failed events. Tallyfy Manufactory data, or data from systems sending events to it, can provide these counts. * **Timestamps:** Manufactory events will typically have timestamps associated with their creation, ingestion by Manufactory, and various processing stages. These are essential for latency-based SLIs. * **Manufactory Metrics/Exports (if available):** If Tallyfy Manufactory exposes its own operational metrics (e.g., number of events processed by a project, error rates for an actor) or allows event data to be exported, this data can be directly fed into your SLO tracking and alerting tools. ## Practical steps for setting up alerts for Manufactory workflows 1. **Choose an SLO Tracking Tool:** This could be your existing monitoring or observability platform if it supports event-based SLO calculations and burn rate alerting. If not, you might consider dedicated SLO tooling. 2. **Feed Manufactory Event Data:** Determine how to get the relevant event data (success/failure status, counts, timestamps for events related to Manufactory) into your SLO tool. This might involve: * Your applications sending event data directly to the SLO tool in parallel with sending to Manufactory. * Using an API or webhooks from Manufactory (if available) to push event outcomes. * Querying Manufactory's data store or logs (if accessible and suitable for real-time analysis). 3. **Define SLIs and SLOs:** Configure your chosen SLIs and their target SLOs within the tool, based on your Manufactory workflows. 4. **Configure Burn Rate Alerts:** Set up alerts based on different error budget burn rates and time windows (e.g., fast burn over 1 hour, slower burn over 24 hours). 5. **Develop Playbooks:** When an alert fires for a Manufactory-related SLO, what are the initial investigation steps? How should engineers use Tallyfy Manufactory's interface, event data, and other tools to diagnose the issue? ## Example scenario: Alerting on a failing Manufactory actor * **SLI:** Percentage of successful executions for a critical `OrderValidationActor` within a Tallyfy Manufactory project. * **SLO:** 99.95% success rate[^2] over a rolling 7-day period. * **Alerting:** If the `OrderValidationActor` starts failing more frequently (e.g., due to a new type of malformed event payload it can't handle), the error budget for this SLO will begin to deplete. A burn rate alert would notify the on-call team that, at the current failure rate, the 7-day SLO for this actor is in jeopardy. * **Action:** The team would then investigate the `OrderValidationActor` within Manufactory, examine the attributes of the failing events, check actor logs (if available), and potentially look at traces for the problematic event flows. ## Iterating and improving your alerts Setting up SLOs and alerts is not a one-time task: * **Regularly review alert effectiveness:** Are your alerts for Tallyfy Manufactory processes truly actionable? Are you experiencing false positives or negatives? * **Adjust SLO targets and alert thresholds:** As your understanding of your Manufactory workflows and their typical performance improves, refine your SLOs and alerting rules. * **Ensure alerts provide context:** Alerts should give responders enough initial information to efficiently start investigating issues related to Tallyfy Manufactory, perhaps by linking directly to relevant views or queries. By adopting an SLO-based approach, you can transform your alerting for Tallyfy Manufactory from a source of noise into a reliable system for maintaining and improving the reliability of your critical event-driven processes. [^1]: Rate of error budget consumption vs time remaining; high burn means exhausting budget faster than planned [^2]: Allows approximately 36 seconds of downtime or errors per day in a continuous system - **[Understanding structured events](https://tallyfy.com/products/manufactory/best-practices/understanding-structured-events/)**: Structured events formatted as key-value pairs enable Tallyfy Manufactory to efficiently route and trigger workflows while providing the machine-parsable and searchable data needed for powerful querying and analysis of event-driven systems. For Tallyfy Manufactory to effectively manage your event-driven workflows and for you to gain deep observability insights, the events themselves must be well-structured. This article explores what structured events are and how to design them for optimal use with Manufactory (and avoid the debugging nightmares that come with poorly structured data). ## What are structured events? Structured events are records of occurrences within your systems that are formatted as key-value pairs. This organization makes them easily machine-parsable, searchable, and analyzable. Think of a structured event like a well-organized spreadsheet, where each piece of information has its own column (key) and corresponding entry (value). This is in stark contrast to unstructured logs, which are often just lines of free-form text - more like a pile of handwritten notes that someone threw into a blender. For example, instead of a log line saying: `"User Bob (ID:123) failed to process payment for order ORD456 at 10:30 AM due to insufficient funds."`, a structured event would represent this as: ```json { "timestamp": "2024-10-27T10:30:00Z", "event_type": "PaymentProcessingFailed", "user_id": "123", "user_name": "Bob", "order_id": "ORD456", "reason_code": "INSUFFICIENT_FUNDS", "message": "Payment failed due to insufficient funds." } ``` This structure is critical for Tallyfy Manufactory to efficiently route, trigger actions, and allow for powerful querying and analysis of your event data. Without structure, automating responses or gaining insights from event streams becomes significantly more challenging (basically impossible without a lot of painful regex). ## Key characteristics of effective structured events To be truly useful for observability, especially with a system like Tallyfy Manufactory, your structured events should possess several key characteristics: * **Arbitrarily wide:** Events should be able to accommodate a diverse and potentially large number of fields (dimensions). This allows you to capture all relevant context. * **High-cardinality fields:** Include fields that can have many unique values. For example, a `userID`, `orderID`, or a specific `eventID` generated by or for Manufactory are high-cardinality[^1]. These are essential for pinpointing specific instances or users (think unique identifiers, not status fields with 3 possible values). * **Rich context:** Go beyond purely technical data. Include business-specific information like `customerTier`, `productCategory`, or `region`. This allows you to correlate system behavior with business metrics when analyzing events that pass through Manufactory. * **Timestamps and durations:** Accurate timestamps are vital for sequencing events and understanding when things happened. If an event represents an operation, its duration is also key for performance analysis. Manufactory itself will add timestamps related to its own processing stages. ## Designing event schemas for Tallyfy Manufactory When designing the structure (or schema) for events that will be processed by or sent to Tallyfy Manufactory, consider the following: * **Identify critical information:** What data does Manufactory need to perform its routing and trigger logic? What information will *you* need to understand an event's lifecycle and troubleshoot issues related to its processing within or via Manufactory? * **Standardization vs. flexibility:** While it's beneficial to standardize common field names across your events (e.g., `trace_id`, `user_id`, `event_source`), your schema should also be flexible enough to accommodate event-specific data relevant to different Manufactory projects or actors. * **Naming conventions:** Adopt clear, consistent, and descriptive field names. Using a nested structure (e.g., `event.name`, `event.source`, `manufactory.event_id`, `manufactory.actor_id`) can help organize attributes. snake_case or camelCase are common choices (just pick one and stick with it - mixed conventions are a special kind of hell). ### Essential fields for events processed by Manufactory While your specific needs will vary, here are some commonly essential fields for events interacting with Tallyfy Manufactory: * **Unique Identifiers:** A unique ID for the event instance itself (e.g., `event_id`), and any relevant correlation IDs (e.g., `workflow_instance_id`, `order_id`). If the event is part of a distributed trace, include `trace_id` and `span_id`. * **Event Source:** The system or service that originally generated the event (e.g., `CRMWebService`, `PaymentGatewayCallback`). * **Event Type/Name:** A clear, descriptive name for the event (e.g., `CustomerProfileUpdated`, `InventoryItemRestocked`, `ManufactoryTriggerFired`). * **Payload:** The actual data pertinent to the event, structured in a way that Manufactory actors or downstream systems can easily consume. * **Timestamps:** At a minimum, the timestamp of when the event was created at its source. Manufactory will likely add its own timestamps for ingestion and processing milestones. * **Status Indicators:** Fields that can indicate the success or failure of the operation the event represents, or reasons for failure if applicable, especially for events generated *by* Manufactory actors. ## Examples of good vs. bad event structures for Manufactory Let's illustrate with an example of an event that Tallyfy Manufactory might ingest or trigger. **Bad example (unstructured log line):** `"LOG: Order ORD789 processed by fulfillment_actor in Manufactory project 'OrderProcessing' at 2024-10-27 14:15:00 UTC, status success, items: 3, user: jane.doe@example.com"` This is hard to query. To find all successful order processing events for Jane Doe, you'd need complex text parsing (and probably cry a little). **Good example (structured JSON event for Manufactory):** ```json { "event_id": "evt_67890fghij", "trace_id": "trace_12345abcde", "event_source": "TallyfyManufactory.Project.OrderProcessing", "event_type": "OrderFulfillmentStepCompleted", "timestamp_occurred": "2024-10-27T14:15:00Z", "manufactory_project_id": "OrderProcessing", "manufactory_actor_name": "fulfillment_actor", "order_id": "ORD789", "user_email": "jane.doe@example.com", "item_count": 3, "status": "SUCCESS", "payload": { "shipment_details_retrieved": true, "inventory_updated": true } } ``` This good example is far superior because: * Each piece of information is a distinct field, making it easy to query (e.g., `WHERE user_email = 'jane.doe@example.com' AND status = 'SUCCESS'`) - no regex nightmares. * Manufactory can use fields like `manufactory_project_id` or `event_type` for routing or triggering specific logic. * Numerical fields like `item_count` can be aggregated. * The nested `payload` keeps related details organized. ## How Tallyfy Manufactory uses structured events Tallyfy Manufactory, as an event ingestion and lifecycle engine, fundamentally relies on well-structured event data to: * **Perform efficient routing and filtering:** Manufactory projects can use specific event attributes to decide which events to process or which actors to trigger. * **Execute actor logic:** Actors within Manufactory often need to consume specific data points from the event payload to perform their tasks. * **Enable powerful user queries:** For you to understand what Manufactory is doing, you need to be able to search and filter the events it has processed based on their attributes. * **Provide data for monitoring and alerting:** Structured event data is essential for creating meaningful metrics and alerts about the health and performance of your event processing through Manufactory. ## Iterating on your event schemas Your event schemas don't need to be perfect from day one. Start by instrumenting the information you know you'll need for Tallyfy Manufactory to function and for your initial troubleshooting scenarios. As your understanding of your event flows deepens and your observability practice matures, you can add more context to your events. Better to ship something useful than to bikeshed the perfect schema for months. It's important to consider how your event schemas might evolve. If Manufactory or other downstream systems have strict expectations about the event structure, plan for versioning your event schemas or ensure changes are backward-compatible to avoid breaking integrations (because nothing ruins your day like a schema change that breaks everything downstream). [^1]: Refers to fields with many unique values like user IDs, versus low-cardinality fields like status codes - **[Best practices for instrumenting applications](https://tallyfy.com/products/manufactory/best-practices/instrumenting-applications-for-manufactory/)**: Good instrumentation in Tallyfy Manufactory requires including unique identifiers along with event semantics and timestamps and rich contextual payload data to enable effective routing and processing while supporting meaningful analysis and troubleshooting of event-driven workflows. Effective observability hinges on the quality of data your systems produce. For Tallyfy Manufactory to provide maximum value in managing and giving insight into your event-driven workflows, the events it ingests must be well-instrumented. This means thoughtfully deciding what information to include in your events. ## Why good instrumentation matters for Tallyfy Manufactory The principle of "garbage in, garbage out" applies strongly here. The richness and clarity of the event data you send to Tallyfy Manufactory directly impacts: * **Manufactory's effectiveness:** Well-structured events with relevant data enable Manufactory to perform its core functions—like routing events to the correct [projects](/products/manufactory/projects/), triggering appropriate [actors](/products/manufactory/actors/), and managing event lifecycles—more accurately and efficiently. * **Your ability to analyze and troubleshoot:** Richly contextualized events are the raw material for meaningful analysis. Without good instrumentation, identifying the root cause of a problem in an event flow involving Manufactory becomes a difficult guessing game. * **The value of your observability practice:** The deeper your instrumentation, the more profound the insights you can derive about your system's behavior through Manufactory and associated observability tools. ## General principles of good instrumentation Before diving into specifics for Tallyfy Manufactory, let's cover some universal principles for good instrumentation: * **Instrument for the data consumer:** Always think about who will be using this event data and what questions they will need to answer. This includes developers debugging issues, operations teams monitoring system health, and potentially product managers understanding feature usage through events processed by Manufactory. * **Context is king:** The more relevant context you can pack into an event, the more useful it becomes. Don't skimp on details that might seem minor now but could be crucial later during an investigation. * **Be consistent:** Use standardized field names (e.g., `user_id`, `trace_id`, `event_type`) and data formats where possible. This makes events easier to correlate and query across different sources and within Manufactory. * **Start early in the development lifecycle:** Don't treat instrumentation as an afterthought. Build it in as you develop new features or services that will interact with Tallyfy Manufactory. * **Iterate and refine:** Instrumentation is not a one-time setup. As your systems and your understanding of them evolve, you'll likely identify new pieces of information that would be valuable to include in your events sent to Manufactory. ## What data to include in events sent to Tallyfy Manufactory When instrumenting an application to send an event to Tallyfy Manufactory, or when an actor within Manufactory generates an event, consider including the following types of data: * **Unique Identifiers:** * `event_id`: A globally unique identifier for this specific event instance. * `correlation_id`: An identifier that links this event to a broader business transaction or workflow instance (e.g., an `order_id` that ties together multiple events related to a single customer order). * Identifiers for key business entities involved: `user_id`, `product_id`, `session_id`. * If integrated with a Manufactory project: `manufactory_project_id`. * **Event Semantics:** * `event_type` or `event_name`: A clear, human-readable string describing what happened (e.g., `InvoiceGenerated`, `ShipmentDelayed`, `PaymentAttemptFailed`). * `event_source`: The name of the application, service, or component that originated this event. * `event_version`: Useful if your event schemas change over time, allowing consumers like Manufactory to handle different versions appropriately. * **Timestamps:** * The precise time the event occurred at its source. * Tallyfy Manufactory will typically add its own timestamps for when it ingests or processes events, allowing for latency calculations. * **Payload:** * The core data specific to this event type, structured in a clear and understandable way (e.g., for an `InvoiceGenerated` event, this might include `invoice_id`, `amount_due`, `due_date`). * Avoid overly verbose data if it's not necessary for Manufactory's processing or for later analysis. Be mindful of payload size. * **Tracing Information (if implementing distributed tracing[^1]):** * `trace_id`: The ID for the entire distributed trace this event is part of. * `span_id`: The ID for this specific event's operation within the trace. * `parent_span_id`: The ID of the operation that caused this event. * **Technical Context (optional, but can be very helpful for debugging):** * `hostname` or `container_id` of the emitting service. * `ip_address`. * `environment` (e.g., `development`, `staging`, `production`). * `application_version` or `build_id` of the emitting service. * **Business Context (can greatly enhance analysis):** * `customer_segment` (e.g., `professional`, `smb`, `free_tier`). * `region` (e.g., `us-east-1`, `eu-west-2`). * Relevant `feature_flags_active` at the time of the event. ## Auto-instrumentation vs. manual instrumentation There are generally two approaches to adding instrumentation: * **Auto-instrumentation:** Libraries or agents that automatically capture common events and metrics (e.g., incoming/outgoing HTTP requests, database queries) with minimal code changes. * **Pros:** Quick to set up, provides broad baseline coverage. * **Cons:** May not capture specific business logic or the nuanced context Tallyfy Manufactory needs. Events can be generic. * **Relevance for Manufactory:** More useful for instrumenting the services *around* Manufactory (e.g., the service that calls a Manufactory API, or an actor that calls an external service). The actual events *sent to* Manufactory often require more specific detail than auto-instrumentation provides by default. * **Manual instrumentation:** Explicitly adding code to generate and send events with the exact data fields you define. * **Pros:** Full control over event content, allowing you to tailor events perfectly for Manufactory's needs and your analytical requirements. Essential for capturing business-specific context. * **Cons:** Requires more developer effort. **Recommendation:** For events that are central to Tallyfy Manufactory's operation (i.e., events that trigger Manufactory projects or are processed by its actors), **manual or heavily customized auto-instrumentation is generally preferred.** This ensures the events contain the rich, specific, and contextual data Manufactory needs to function optimally and for you to gain meaningful observability. ## Instrumenting for event lifecycles managed by Manufactory If Tallyfy Manufactory is orchestrating a multi-step business process through its projects and actors: * Ensure events clearly indicate the current **stage or status** of the overall process. * Include a common **correlation identifier** (e.g., `workflow_id`, `case_id`) in all events related to a single instance of that process. * Consider having actors within Manufactory emit their own events (with appropriate context) at the beginning and end of their significant processing steps, or when they make critical decisions. This provides visibility into Manufactory's internal workings. ## Example: Instrumenting an "Order Shipped" event for Manufactory Imagine a `ShippingService` emits an `OrderShipped` event to be processed by Tallyfy Manufactory. Good instrumentation might include: ```json { "event_id": "unique_event_guid_987", "event_type": "OrderShipped", "event_source": "ShippingService", "timestamp_occurred": "2024-10-27T16:45:10Z", "trace_id": "trace_for_order_processing_xyz", "order_id": "ORD-552", "user_id": "usr_jane_doe", "shipment_id": "shp_fedex_123456789", "carrier_name": "FedEx", "tracking_number": "1234567890ABC", "shipping_cost": 25.99, "destination_zip_code": "90210", "items_shipped": [ {"sku": "PROD_A", "quantity": 1}, {"sku": "PROD_B", "quantity": 2} ] } ``` When Tallyfy Manufactory ingests this event, it could trigger actors to: send a shipping confirmation email to the user, update the order status in an e-commerce platform, and notify the inventory system. The rich data allows for precise actions and detailed observability. ## Avoiding common pitfalls * **Sending too little context:** Events become cryptic and hard to correlate or understand, diminishing Manufactory's (and your) ability to act on them. * **Inconsistent data formats or field names:** Makes querying and analysis difficult. * **Including sensitive Personally Identifiable Information (PII)[^2]:** Ensure compliance with data privacy regulations. If sensitive data must be processed by Manufactory, understand its data handling policies and implement appropriate masking or tokenization upstream if necessary. * **Not versioning event schemas:** As your application evolves, so will your events. Versioning helps manage these changes gracefully, especially for consumers like Tallyfy Manufactory. ## How good instrumentation enhances the value of Tallyfy Manufactory Thoughtful instrumentation is not just an operational task; it's an investment that directly boosts the value you get from Tallyfy Manufactory by: * Enabling more precise and intelligent event routing and filtering within your Manufactory [projects](/products/manufactory/projects/). * Allowing for more sophisticated and context-aware logic within your Manufactory [actors](/products/manufactory/actors/). * Providing superior visibility into the health, performance, and outcomes of your event-driven processes. * Making it significantly easier and faster to debug issues when they arise in workflows that touch Tallyfy Manufactory. [^1]: A method to track requests across multiple services using trace_id, span_id to understand flow [^2]: Data like SSN, email, or name that can identify individuals - requires special handling - **[What is observability?](https://tallyfy.com/products/manufactory/best-practices/what-is-observability/)**: Observability enables deep understanding of complex systems through detailed event data analysis to explore and debug both known and unknown issues without relying solely on predefined metrics. Observability helps you understand what's happening inside your complex systems. It's about being able to ask any question about your system's state and get answers, even for conditions you didn't anticipate. ## Defining observability in simple terms Imagine you're trying to understand why your car is making a strange noise. Traditional monitoring is like having a few dashboard lights: oil pressure is low, engine temperature is high. These are pre-defined checks for known problems. Observability, on the other hand, is like having a sophisticated diagnostic tool that can query every sensor in your car, look at historical data, and correlate different readings to figure out precisely what's going on, even if it's a problem the car manufacturer never specifically designed a warning light for. It's the ability to understand the internal workings of your system by examining its external outputs – primarily the rich, detailed data from events and traces. A key aspect of observability is its power to help you debug "unknown unknowns." These are the novel or bizarre states your system might get into that you couldn't have predicted and therefore couldn't have set up a specific monitor for. With Tallyfy Manufactory managing crucial event lifecycles, being able to explore these unknown states is vital. ## How observability differs from traditional monitoring While often used interchangeably, observability and monitoring serve different, though complementary, purposes, especially in the context of event-driven systems like those Tallyfy Manufactory supports. **Traditional Monitoring:** * **Focuses on "known unknowns":** It answers questions you already know to ask. For example, "Is the CPU utilization high?" or "Is the database connection pool exhausted?" * **Relies on pre-defined metrics and dashboards:** You set up specific checks and visualizations for conditions you anticipate might go wrong. * **Primarily reactive:** Alerts fire when a known threshold is breached, prompting you to investigate a problem that is likely already occurring. **Observability:** * **Addresses "unknown unknowns":** It helps you understand issues you didn't predict. For example, "Why are events from a specific region processed 50% slower only between 2 AM and 3 AM on Tuesdays after a specific Manufactory actor runs?" * **Relies on rich, high-cardinality event data:** This detailed data allows for deep exploration and ad-hoc querying. * **Enables proactive exploration and debugging:** You can interrogate your system to understand nuanced behaviors and identify subtle issues before they escalate. For complex, event-driven systems where Tallyfy Manufactory plays a central role in ingesting, routing, and triggering actions based on events, monitoring alone often falls short. The sheer number of potential states and interactions makes it impossible to pre-define all relevant metrics or anticipate every failure mode. Observability provides the tools to navigate this complexity. ## Key benefits of observability for Tallyfy Manufactory users Implementing observability practices around your Tallyfy Manufactory event data brings significant advantages: * **Faster troubleshooting:** When an event fails to process or a workflow involving Manufactory gets stuck, rich event data allows you to quickly pinpoint the "why" and "where." You can trace the event's journey, inspect its payload at various stages (including within Manufactory), and understand the context of the failure. * **Understanding event lifecycles:** Gain deep clarity on how events are ingested by Manufactory, how they are processed by different [projects](/products/manufactory/projects/) or [actors](/products/manufactory/actors/), and how they trigger subsequent actions. This is crucial for optimizing complex event chains. * **Improving system reliability and performance:** By analyzing event patterns, error rates, and processing times through Manufactory, you can identify bottlenecks, recurring error types, and opportunities for optimization in your event-driven workflows. * **Increased confidence in changes:** When you modify a Manufactory project, update an actor, or integrate a new event source, observability allows you to see the real-time impact of these changes on event processing and system behavior. * **Proactive problem detection:** You can often identify subtle anomalies or deviations from expected event behavior within Manufactory before they escalate into user-facing outages or data inconsistencies. ## Observability with Tallyfy Manufactory: A practical example Consider an automated customer onboarding process. A new customer signs up on your website, which generates a `CustomerRegistered` event. This event is sent to Tallyfy Manufactory. Manufactory is configured with a project that listens for `CustomerRegistered` events. Upon receiving such an event, it triggers several actors: 1. An actor to create a welcome package in your CRM. 2. An actor to send a welcome email via your marketing automation platform. 3. An actor to provision access to specific product features. Now, imagine a customer reports they never received their welcome email. * **Without observability:** You might check email logs, CRM logs, and access control logs separately, trying to piece together what happened. It could be time-consuming. * **With observability:** You would find the `CustomerRegistered` event associated with that customer. You could then trace its journey: * Confirm Manufactory ingested the event. * See if the Manufactory project correctly identified and triggered the "send welcome email" actor. * Examine the event data passed to that actor and any response or error it logged back to an observable system. This allows you to quickly determine if the issue was with the event data itself, a configuration in Manufactory, or a problem within the welcome email actor or the email platform it called. This targeted investigation saves significant time and effort. ## Moving beyond metrics and logs with Manufactory Traditional metrics and logs certainly provide value. Metrics can give you a high-level overview of event throughput in Manufactory (e.g., "events processed per minute"), and logs from Manufactory actors can offer specific error details. However, Tallyfy Manufactory's core strength lies in its event-centric nature. The rich, structured event data that Manufactory processes and potentially enriches offers a much deeper level of insight for event-driven architectures. While a metric might tell you *that* event processing is slow, observable event data (especially when traced) can help you understand *why* specific events are slow, which services are involved, and what particular conditions correlate with the slowness. This granular detail is key to truly understanding and optimizing the complex workflows managed by Tallyfy Manufactory. ### Events - **[Create events schema](https://tallyfy.com/products/manufactory/events/create_schema/)**: Tallyfy Manufactory allows you to create events schemas by sending a POST request to /events/schema with organization ID project ID and attribute definitions using proper authentication headers. ## Design your events schema You can create events schema in Tallyfy Manufactory using the endpoint `POST /events/schema`. ## Authentication The following header is required for all API calls: - `X-Manufactory-Auth` - Manufactory access token ### Required keys - `org_id` (required) string - Manufactory org ID. - `project_id` (required) number - The project ID associated with this schema. - `attributes` (required) object - Pairs containing attribute name and the corresponding data type. A complete list of [valid data types](/products/manufactory/data-types/). ### Request example ```json { "org_id": "xyz", "project_id": 12345, "attributes":{ "Event name": "TEXT", "Event type": "TEXT", "Made purchase": "BOOLEAN" } } ``` ### Response example ```json { "message": "Events schema created successfully" } ``` - **[Delete events schema](https://tallyfy.com/products/manufactory/events/delete_schema/)**: Tallyfy Manufactory allows deletion of event schemas through a DELETE API endpoint that requires organization ID project ID and authentication token in the request header. You can delete an event schema in Tallyfy Manufactory using the endpoint `DELETE /events/schema/{org_id}/{project_id}`. ### Authentication The following header is required for all API calls: - `X-Manufactory-Auth` - Manufactory access token ### Required values - `org_id` (required) string - Manufactory org ID. - `project_id` (required) number - Manufactory project ID. - **[Get events schema](https://tallyfy.com/products/manufactory/events/get_schema/)**: The GET endpoint retrieves event schema attributes like event name type and purchase status for a specific project within an organization using Manufactory access token authentication. You can fetch an events schema belonging to a specific project in Tallyfy Manufactory using the endpoint `GET /events/schema/{org_id}/{project_id}`. ### Authentication The following header is required for all API calls: - `X-Manufactory-Auth` - Manufactory access token ### Required values - `org_id` (required) string - Manufactory org ID. - `project_id` (required) number - Manufactory project ID. ### Response example ```json { "attributes": [ { "name": "event_name", "display_name": "Event Name", "data_type": "text" }, { "name": "event_type", "display_name": "Event Type", "data_type": "text" }, { "name": "made_purchase", "display_name": "Made Purchase", "data_type": "boolean" } ], "org_id": "xyz", "project_id": 12345 } ``` ### Projects - **[Create a project](https://tallyfy.com/products/manufactory/projects/create_project/)**: The Tallyfy Manufactory API allows creating new projects through a POST endpoint that requires authentication and organization details including name description and timezone preferences. You can create a project in Tallyfy Manufactory using the endpoint `POST /projects`. ### Authentication The following header is required for all API calls: * `X-Manufactory-Auth` - Manufactory access token ### Required keys * `org_id` (required) string - Manufactory org ID. * `name` (required) string - The desired project name. * `description` (required) string - A description for the project. * `timezone` (required) string - The preferred timezone for displaying dates. For example, `New York (Eastern)` would be `America/New_York`. A complete list of [valid timezones](https://go.tallyfy.com/resources/timeZone.json) (All timestamps are stored in UTC timezone, this selection is intended for displaying only) ### Request example ```json { "org_id": "master", "name": "Prod", "description": "A project for prod data", "timezone": "America/Chicago" } ``` ### Response example ```json { "org_id": "xyz", "project_id": 10003, "name": "Prod", "description": "A project for prod data", "timezone": "America/Chicago", "created_at": "2023-02-08 17:13:26", "project_key": "***********************" } ``` - **[Get a project](https://tallyfy.com/products/manufactory/projects/get_project/)**: The GET endpoint retrieves a single project's details including name description timezone and creation date by providing organization ID project ID and authentication token. You can get all Manufactory projects using the endpoint `GET /projects/{org_id}/{project_id}`. ### Authentication The following header is required for all API calls: - `X-Manufactory-Auth` - Manufactory access token ### Required values - `org_id` (required) string - Manufactory org ID. - `project_id` (required) number - Manufactory project ID. ### Response example ```json { "org_id": "xyz", "project_id": 100, "name": "Staging", "description": "A project for staging data", "timezone": "America/Chicago", "created_at": "2023-02-26T18:53:18Z", "project_key": "***********************" } ``` - **[Delete a project](https://tallyfy.com/products/manufactory/projects/delete_project/)**: A Manufactory project can be deleted through a DELETE request by providing the organization ID project ID and authentication token in the header. You can delete a project using the endpoint `DELETE /projects/{org_id}/{project_id}`. ### Authentication The following header is required for all API calls: - `X-Manufactory-Auth` - Manufactory access token ### Required values - `org_id` (required) string - Manufactory org ID. - `project_id` (required) number - Manufactory project ID. - **[Get all projects](https://tallyfy.com/products/manufactory/projects/get_projects/)**: The GET endpoint retrieves all Manufactory projects for an organization by providing the org_id and authentication token in the header which returns project details like IDs names descriptions and timezones. You can get all your Manufactory projects using the endpoint `GET /projects/{org_id}`. ### Authentication The following header is required for all API calls: - `X-Manufactory-Auth` - Manufactory access token ### Required values - `org_id` (required) string - Manufactory org ID. ### Response example ```json [ { "org_id": "xyz", "project_id": 100, "name": "Staging", "description": "A project for staging data", "timezone": "America/Chicago", "created_at": "2023-02-26T18:53:18Z", "project_key": "***********************" }, { "org_id": "xyz", "project_id": 101, "name": "Prod", "description": "A project for prod data", "timezone": "America/Chicago", "created_at": "2023-02-26T19:04:06Z", "project_key": "***********************" } ] ``` - **[Reset project key](https://tallyfy.com/products/manufactory/projects/reset_key/)**: A POST request to reset a project's key requires an access token and returns project details including the new key along with basic information like name timezone and creation date. You can reset a project's key using the endpoint `POST /projects/{org_id}/{project_id}/keys`. ### Authentication The following header is required for all API calls: - `X-Manufactory-Auth` - Manufactory access token ## Required values - `org_id` (required) string - Manufactory org ID. - `project_id` (required) number - Manufactory project ID. ### Response example ```json { "org_id": "xyz", "project_id": 10003, "name": "Prod", "description": "A project for prod data", "timezone": "America/Chicago", "created_at": "2023-02-08 17:13:26", "project_key": "***********************" } ``` - **[Update a project](https://tallyfy.com/products/manufactory/projects/update_project/)**: The PUT endpoint enables updating a Manufactory project's name description and timezone by providing the organization ID and project ID along with optional fields in the request body. You can update a project using the endpoint `PUT /projects/{org_id}/{project_id}`. ## Authentication The following header is required for all API calls: - `X-Manufactory-Auth` - Manufactory access token ### Required values - `org_id` (required) string - Manufactory org ID. - `project_id` (required) number - Manufactory project ID. ### Required keys - `name` (optional) string - The desired project name. - `description` (optional) string - A description for the project. - `timezone` (optional) string - The preferred timezone for displaying dates. For example, `New York (Eastern)` would be `America/New_York`. A complete list of [valid timezones](https://go.tallyfy.com/resources/timeZone.json) (All timestamps are stored in UTC timezone, this selection is intended for displaying only) ### Request example ```json { "name": "Dev" } ``` ### Response example ```json { "org_id": "xyz", "project_id": 10003, "name": "Dev", "description": "A project for prod data", "timezone": "America/Chicago", "created_at": "2023-02-08 17:13:26", "project_key": "***********************" } ``` ### Implementation - **[Configuring events schema](https://tallyfy.com/products/manufactory/implementation/configuring_events_schema/)**: Contact Tallyfy for more information about configuring events schema in Manufactory while exploring related guides on user schema configuration planning events and implementation processes. For more information about configuring events schema in Tallyfy Manufactory, contact us - **[Configuring user schema](https://tallyfy.com/products/manufactory/implementation/configuring_users_schema/)**: Tallyfy Manufactory offers implementation resources covering user schema configuration event tracking and project planning with related guides for successful manufacturing operations integration. For more information about configuring user schema in Tallyfy Manufactory, contact us - **[Planning](https://tallyfy.com/products/manufactory/implementation/planning/)**: The page offers contact information for Tallyfy Manufactory implementation planning and provides related articles covering user schema configuration event tracking pricing and systematic integration approaches. For more information about planning your Tallyfy Manufactory implementation, contact us ### Collector - **[Collecting events via our CLI agent](https://tallyfy.com/products/manufactory/collector/agent/)**: The Tallyfy Manufactory collector agent provides a lightweight solution for off-loading API event transmission and enables data collection from IoT devices with limited computing power or connectivity constraints. ## Agent route The Tallyfy Manufactory collector allows you to send actors data and events, which can be viewed in our custom interface. The Manufactory agent can be useful in certain scenarios where you need to off-load your API from sending the events. Also, it can be used in any IoT device that has limited computing power or connectivity. Please discuss the agent with us if you're interested in it https://tallyfy.com/amit - **[Collecting events via websocket](https://tallyfy.com/products/manufactory/collector/websocket/)**: Tallyfy Manufactory's websocket connection enables real-time bidirectional communication between browser and server for persistent data exchange sessions. A websocket connection in Tallyfy Manufactory provides real-time bi-directional data exchange with the server. It's ideal for long-lived sessions in browsers. - **[Collecting events via the REST API](https://tallyfy.com/products/manufactory/collector/rest_api/)**: The Tallyfy Manufactory REST API enables transmission of actors data and events into the platform through multiple integration methods including REST API websocket and CLI agent options with secure authentication and data collection capabilities. The Tallyfy Manufactory REST API allows you to send actors data and events into the platform. ### Agent - **[Authentication for the agent collector](https://tallyfy.com/products/manufactory/collector/agent/auth/)**: To authenticate with Tallyfy Manufactory you must configure a YAML file containing your organization ID project ID and project key values which should be placed in the same directory as the manufactory-agent executable. ## Authentication Before you can start sending data to Tallyfy Manufactory[^1], you need to fill the config file with the following values. ### Required keys - `org_id` (required) string - Manufactory org ID. - `project_id` (required) number - The project ID associated with this schema. - `project_key[^2]` (required) string - of the project to be populated. ### config.yaml ```yaml org_id: xyz project_id: 12345 project_key: b0iqA8ezfhPgacy32PybGWghRkGrOo9H ``` `manufactory-agent` and `config.yaml` file should be within the same folder. [^1]: Directus-based data management system for custom schemas and workflows [^2]: A unique API key generated per project for secure authentication - **[Send events via the CLI agent](https://tallyfy.com/products/manufactory/collector/agent/send_events/)**: The Tallyfy Manufactory agent enables sending actor-generated events by requiring base64-encoded actor and event objects that contain attribute name-value pairs conforming to predefined schemas. ## Send events After filling the required values in the previous section, we can start sending actor-generated events via the Tallyfy Manufactory agent. ### Required keys - `--actor` (required) object - Pairs containing attribute name and the corresponding value while considering the correct attribute names and data types. Please refer to [Get Actors schema](/products/manufactory/actors/get_schema/). - `--event` (required) object - Pairs containing attribute name and the corresponding value while considering the correct attribute names and data types. Please refer to [Get events schema](/products/manufactory/events/get_schema/). ### Actor example ```json { "city": "New York", "country": "USA", "username": "john.doe", "email": "john.doe@email.com" } ``` ### Event example ```json { "event_name": "login", "event_type": "user-actions", "made_purchase": false } ``` Before we pass actor and event objects, we need to encode the objects using base64[^1]. ### Agent example ```shell manufactory-agent --actor=ewogICAgImNpdHkiOiAiTmV3I \ --event=ewogICAgImV2ZW50X25hbWUiO== ``` The agent will handle the authentication and sending events, then it will shut down. [^1]: Binary-to-text encoding scheme that converts binary data into ASCII characters for safe transmission ### Websocket - **[Authentication for the web socket collector](https://tallyfy.com/products/manufactory/collector/websocket/auth/)**: Tallyfy Manufactory requires websocket client authentication through a POST /auth endpoint using organization ID project ID and actor profile data to generate a 12-hour session UUID. Before you can start sending data to Tallyfy Manufactory via a websocket, you need to authenticate the client/end-user. You can authenticate users using the endpoint `POST /auth`. Required header: - `X-Manufactory-Auth` - Project key of the project to be populated. ### Required keys - `org_id` (required) string - Manufactory org ID. - `project_id` (required) number - The project ID associated with this schema. - `actor_profile` (required) object - Pairs containing attribute name and the corresponding value while considering the correct attribute names and data types. Please refer to [Get Actors schema](/products/manufactory/actors/get_schema/). ### Request example ```json { "org_id": "xyz", "project_id": 12345, "actor_profile":{ "city": "New York", "country": "USA", "username": "john.doe", "email": "john.doe@email.com" } } ``` ### Response example ```json { "org_id": "xyz", "project_id": 12345, "actor_profile_id": 1, "client_uuid": "dcd21714-894c-46bc-9d59-ae9f22753205" } ``` The generated client UUID[^1] is limited to this specific user profile, and it's valid for a 12 hours session[^2]. After 12 hours, you would need to re-authenticate the client. [^1]: Universally Unique Identifier - a standardized 128-bit format for session tracking [^2]: Session expires at exactly 12 hours from generation, not based on activity - **[Connect to our web socket server](https://tallyfy.com/products/manufactory/collector/websocket/connect_to_ws/)**: Tallyfy Manufactory websocket authentication requires establishing a connection to wss://collector.tallyfy.com/ws then sending an auth message with five required keys (type org_id project_id client_uuid actor_profile_id) to pair the connection with the authenticated client before events can be transmitted. After successful authentication and getting client UUID along with actor profile ID[^1], you can connect to the Tallyfy Manufactory websocket server: `wss://collector.tallyfy.com/ws` Once a websocket connection is established you will receive a message `Manufactory Collector ✅` ## WebSocket Authentication Flow This diagram shows the complete authentication handshake between your client and the Manufactory WebSocket server. [Diagram removed for brevity] ### What to notice - **Two-phase authentication**: First the WebSocket connection itself, then the authentication message exchange - **Required credentials**: The auth message must include all five required keys (type, org_id, project_id, client_uuid, actor_profile_id) - **Sequential flow**: Each step must complete successfully before proceeding - the connection won't accept events until authentication succeeds The next step is that we need to pair the connection with the client/end-user. This is where actor profile ID and client UUID become active. ### Required keys - `type` (required) string - The message type, in this case we will be using `auth`. - `org_id` (required) string - Manufactory org ID. - `project_id` (required) number - The project ID associated with this schema. - `actor_profile_id` (required) number - The actor profile ID we got after authentication. - `client_uuid` (required) string - the generated UUID we got after authentication. ### Websocket message example ```json { "type": "auth", "org_id": "xyz", "project_id": 12345, "client_uuid": "e17a56a9-596f-40e6-b01c-d37136df1de8", "actor_profile_id": 1 } ``` ### Websocket reply example ```json { "type": "auth", "status": "ok" } ``` Now we are able to send actor's generated events via the open websocket channel. [^1]: A unique identifier for the authenticated user within the Tallyfy organization context - **[Send events via the web socket](https://tallyfy.com/products/manufactory/collector/websocket/send_events/)**: Websocket events can be sent to Tallyfy Manufactory using a JSON message containing a type field set to "event" and an attributes object with the event data which returns a confirmation message upon successful processing. After establishing a websocket connection with Tallyfy Manufactory[^1], we can start sending user-generated events via the open channel. ### Required keys - `type` (required) string - The message type, in this case we will be using `event`. - `attributes` (required) object - Pairs containing attribute name and the corresponding value while considering the correct attribute names and data types. Please refer to [get events schema](/products/manufactory/events/get_schema/). ### Websocket message example ```json { "type": "event", "attributes": { "event_name": "login", "event_type": "user-actions", "made_purchase": false } } ``` ### Websocket reply example ```json { "type": "event", "status": "ok" } ``` [^1]: Tallyfy's event tracking and analytics platform for process automation insights ### Rest_api - **[Send events via the REST API](https://tallyfy.com/products/manufactory/collector/rest_api/send_events/)**: The POST /events endpoint enables sending actor profiles to Tallyfy Manufactory by providing organization ID project ID actor profile object and event attributes with proper schema validation. You can send actor profiles to Tallyfy Manufactory using the endpoint `POST /events`. ### Required keys - `org_id` (required) string - Manufactory org ID. - `project_id` (required) number - The project ID associated with this schema. - `actor_profile` (required) object - Pairs containing attribute name and the corresponding value while considering the correct attribute names and data types. Please refer to [Get Actors schema](/products/manufactory/actors/get_schema/). - `attributes` (required) object - Pairs containing attribute name and the corresponding value while considering the correct attribute names and data types. Please refer to [Get events schema](/products/manufactory/events/get_schema/). ### Request example ```json { "org_id": "demo", "project_id": 12345, "actor_profile": { "microservice": "accounts-ms" }, "attributes": { "request_method": "POST", "request_url": "/login", "request_body": { "username": "john", "password": "123" }, "request_ip": "1.1.1.1" } } ``` ### Response example ```json { "message": "success" } ``` --- ## Pro - **[Introduction](https://tallyfy.com/products/pro/)**: Tallyfy transforms business processes into automated self-driving workflows that anyone can create in minutes without coding - saving organizations 2 hours per employee daily through real-time tracking and automatic task routing while eliminating the 90% knowledge loss from traditional training methods. Tallyfy turns your business processes into self-driving workflows in minutes - without coding or flowcharts. It's designed for non-technical people. Whether you have lots of papercuts or big inefficient processes - hundreds of organizations are saving 2 hours (per employee) daily with Tallyfy. Simple workflow is a basic human right. Tallyfy is here to make AI useful and practical for your everyday processes. ![Master template creating multiple client processes with progress tracking - showing one template spawning four running workflows at 25%, 50%, 75% and complete stages with assigned team members](https://screenshots.tallyfy.com/illustrations/pro-homepage.jpeg) ### Problems Tallyfy solves * **Start quick** - AI creates or imports processes in minutes. * **Run it - don't read it** - Remove the burden of reading and remembering everything. Everyone follows the latest process. * **Prevent mistakes** - Prevent tasks being forgotten or inconsistently completed. Ensure nothing falls through the cracks again. * **Track it** - Ensure any process can be tracked in real-time. No need for manual status updates and meetings anymore. * **Improve it** - Easily improve your process. Automate certain tasks. * **Delegate** - Auto-delegate to people, automation or AI. Scale your operations and grow margins while improving quality. Did you know that people forget 90% of their training within a week? It's called the [forgetting curve](/products/pro/tutorials/why-documentation-training-fails-forgetting-curve/)[^1] but Tallyfy embeds guidance directly into tasks. These workflow failures and problems can cost your organization around 20% - 40% of **all work time**. It's an invisible and massive waste. You can't delegate tasks to AI without agreed processes that people already follow. Without standardized processes, using AI becomes guesswork. Tallyfy provides the critical foundation for AI to deliver practical benefits. ### 1. Document Tallyfy centralizes all business procedures where they're actually used - inside active workflows. Capture every task, how to do it, who is doing it and by when. ### 2. Track Instantly turn what you documented into a running workflow. Track who's doing what in real-time - no more busywork asking "what's the status?". Trackable workflows cut status meetings by 80% while ensuring work gets done right every time. Your clients can be assigned work and see progress too. ### 3. Improve Delegate selected task to automations, scripts or AI. Compound improvement and the value of gains in your repeatable processes over time. You can't improve or automate chaos. Tallyfy makes processes visible, measurable, and 40% faster on average. ### How to succeed with any process - **Document** your process in minutes (like a recipe) - **Launch** workflows with one click - processes run themselves - **Track** [tasks](/products/pro/tracking-and-tasks/tasks/) progress and capture data (clients love this). Tallyfy also handles the chore of reminders. - **[Automate](/products/pro/documenting/templates/automations/)** rules with "if this then that" - **Improve** quickly by delegating certain tasks to AI, scripts or middleware. ### Daily workflow benefits 80% of business processes live in email, chat, and spreadsheets. Tallyfy empowers anyone to: - Transform processes into reusable [templates](/products/pro/documenting/templates/) in 10 minutes - Launch client-facing workflows that impress - Eliminate 90% of follow-up emails ## Best-fit processes Tallyfy excels for workflows that: - **Need structured data**: Consistent information collection - **Are frequent**: Occur often enough to benefit from digitization - **Require standardization**: Must be done the same way - **Need to scale**: Establish correctly now to handle higher volumes later - **Are complex**: Many steps or conditional rules hard to remember - **Require audit trails**: Proof of who completed what - **Need tracking**: Visibility for workers, managers, leaders, or customers - **Must be predictable**: Everyone knows what happened and what's next ### Key benefits - **Save 2 hours daily**: Eliminate status updates and follow-ups - **100% consistency**: Every process follows your best practice - **Client transparency**: Share real-time progress externally - **Zero dropped balls**: Automatic handoffs never fail - **40% faster processes**: Data-driven improvements compound ### Unique features - **Client-facing workflows** that make money, not just save money - **[Knowledge-only mode](/products/pro/tutorials/knowledge-only-mode/)** - Publish procedures as searchable reference guides without tracking - perfect for how-to documentation and SOPs that teams need to read but not formally complete - **[Conditional logic automation](/products/pro/documenting/templates/automations/conditional-visibility-guide/)** - Dynamic IF-THEN rules that show/hide tasks based on form inputs, creating adaptive workflows that change based on user selections[^2] - **No-code automation** anyone can set up in 3 clicks - including conditional branching, auto-assignments, and deadline actions - **Self-driving processes** - run themselves with automatic routing - **Works in minutes** - not months of implementation ## Getting started Get your first workflow running in under 10 minutes: :::tip[New user onboarding] **First time using Tallyfy?** The system automatically launches an onboarding process with sample tasks to complete. The first task asks you to mark it complete - simply click the **Complete** button in that task. If the **Start Process** button appears grayed out, complete the onboarding tasks first. This ensures you understand the basics before launching your own processes. ::: ### 1. Create a template [Templates](/products/pro/documenting/templates/) are your workflow blueprints in Tallyfy: - Create with AI in 60 seconds - Import existing SOPs instantly - Start from proven examples Two types that cover everything: - **[Procedure templates](/products/pro/documenting/templates/)**: Multi-step workflows (onboarding takes 5 days → 5 hours)[^3] - **[Document templates](/products/pro/documenting/documents/)**: Smart forms with automatic [routing](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/)[^4] ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-show-template-example.png) ### 2. Launch processes Launch live workflows called [processes](/products/pro/tracking-and-tasks/processes/) - it's this simple: ### 3. Track progress Tallyfy runs workflows on autopilot: - Smart-assigns [tasks](/products/pro/tracking-and-tasks/tasks/) based on workload - Sends updates only when needed (not spam) - Shows live progress to everyone - Never drops handoffs - guaranteed ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-showing-ongoing-process.png) ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-task-within-process.png) ### 4. Improve templates - Collect feedback via comments - Monitor task durations - Update templates easily - Make lasting improvements ## Template creation best practices ### Creating effective procedures #### Start simple Outline main steps first. Tallyfy's AI writes the details in seconds: ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-create-client-onboarding-template-from-tallyfyAI.png) #### Make steps clear Start with action verbs: - Perfect: "Email the estimate to the customer within 24 hours" - Vague: "Handle customer communications" #### Add helpful media Include images/videos for complex instructions: ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-add-media-to-tasks.png) #### Use the right task types Select appropriate types (Task, Approve/Reject, Email Draft): ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-switch-to-approvereject.png) #### Assign clear responsibility ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-assign-a-task-to-somebody.png) #### Set realistic deadlines ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-specify-deadline-to-task.png) #### Use automation rules Apply conditional logic: ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-click-automations.png) #### Plan data collection Use [kick-off forms](/products/pro/launching/triggers/kick-off-forms/): ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-how-to-add-kickoff-forms.png) ### Creating effective documents [Document templates](/products/pro/documenting/documents/) create forms for platform use. #### Add fields Click **New Field** for various [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/): ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-add-field-document.png) #### Reuse existing fields Ensure consistency: ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-select-existing-field-document.png) ## Comparison to traditional tools ### Document tools Word, Google Docs, wikis, and Notion create static documentation. Here's how Tallyfy's active workflows compare: | Static Documentation | Tallyfy Active Workflows | |---------------------|-------------------------| | Reads like a manual | Runs like software | | People must remember to check | Notifications bring work to people | | No accountability tracking | See exactly who did what, when | | Manual status updates | Real-time progress visibility | | Copy-paste for each use | Launch once, runs automatically | | Hope people follow it | Enforces the process | | Separate tools for forms | Forms built into workflow | | Email chains for approvals | Approvals happen in-context | Key differences: - Launch as live processes - not PDFs nobody reads - Tasks happen inside the workflow with assignments and deadlines - [Snippets](/products/pro/documenting/templates/snippets/) eliminate copy-paste[^5] - Auto-[translates](/products/pro/miscellaneous/how-can-i-translate-content-in-tallyfy/) to 25+ languages[^6] - Updates flow to all active processes - See who actually follows procedures - Collect data through forms at each step - Automate handoffs and routing decisions ### Spreadsheets Key differences: - Workflows that run themselves (not manual tracking) - One source of truth - no "v2_final_FINAL.xlsx" - Guests see only their tasks - If-this-then-that automation built in - Clients love the real-time visibility ## Next steps Create your first [template](/products/pro/documenting/templates/) - it takes 10 minutes and saves 10 hours weekly. [^1]: Based on Hermann Ebbinghaus's research, without reinforcement or application, people forget 50% of new information within an hour, 70% within 24 hours, and 90% within a week. Tallyfy solves this by embedding training directly into the workflow. [^2]: Unlike traditional workflow tools that require IT departments to set up complex integrations, Tallyfy's automation rules can be configured by any business user in just a few clicks using simple if-then logic. [^3]: This dramatic time reduction comes from eliminating manual handoffs, automatic task assignment based on availability, and parallel task execution where sequential processing isn't required. [^4]: Document routing uses conditional logic to automatically send forms to the right approvers based on field values - for example, purchase orders over $10,000 go to senior management while smaller amounts route to department heads. [^5]: Snippets are reusable text blocks that update everywhere when changed once. For instance, updating a compliance disclaimer in one place automatically updates it across hundreds of documents and active processes. [^6]: Powered by Azure Cognitive Services, this feature auto-translates task instructions, forms, and process documentation into the user's preferred language, maintaining context and technical accuracy. ### Pro - **[Essentials](https://tallyfy.com/products/pro/documenting/)**: Tallyfy transforms static business documentation into three types of live workflow templates—procedure templates for sequential multi-step processes with automation and document templates for reusable formatted materials with locked sections and form templates for structured data collection—each designed to replace ignored traditional documents with trackable active workflows that stay current. ## Transforming business process documentation You need consistent processes across your teams - that's where Tallyfy comes in. Instead of static documents that gather dust, you get live workflows through three template types. Effective [process documentation](https://tallyfy.com/process-documentation/) turns tribal knowledge into repeatable, trackable workflows. Traditional docs get ignored and outdated. Tallyfy's active workflows stay current while giving you real-time tracking, performance data, and ways to improve continuously. Simple. ### Workflow template types Tallyfy gives you three template types - each one built for different needs: 1. **[Procedure Templates](/products/pro/documenting/templates/)** - These handle your step-by-step workflows, SOPs, and standard procedures. - Perfect when you've got complex processes with steps that depend on each other (think employee onboarding, purchase approvals, compliance procedures). - Automation rules let you skip or add steps based on form answers[^1] - the system adapts as you go. - Assign [tasks](/products/pro/tracking-and-tasks/tasks/) to specific people ([members](/products/pro/documenting/members/)) or entire teams. - Track everything from start to finish. You'll see exactly where each process stands. 2. **[Document Templates](/products/pro/documenting/documents/)** - For your policy documents, reference materials, and company procedures. - Great for docs that need consistent formatting but flexible content order (social media policies, client guidelines, team protocols, compliance documents - you name it). - Set up [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) so team members can fill in specific details while keeping your document structure intact. - Lock certain sections that can't change[^2] - keeps you compliant and on-brand. - Everyone works online. No downloads needed. 3. **Form Templates** - For collecting business data quickly *(Note: This feature is currently being updated and is unavailable)* - Built to gather all your business info in one go - no multi-step hassles. - Mix and match question types and form fields to get exactly what you need. - Export your collected data for analysis or send it to other systems. - Works smoothly with your other workflows. ### Choosing the right template type Not sure which template to use? Here's how to pick: #### Choose Procedure Templates when you need to: - Track multi-step processes where order matters - step 2 can't happen before step 1 - Assign different steps to different people, departments, or teams - Make sure tasks get done in the right order (especially important for compliance) - Keep things moving in a specific sequence from start to finish #### Choose Document Templates when you need to: - Create documents you'll use over and over with the same format - Keep formatting consistent but let people customize the details - Build reusable templates for contracts, proposals, policies, or standard communications - Let your team collaborate on documents while keeping the structure intact #### Choose Form Templates when you need to: - Collect lots of info quickly in one shot - Gather specific data, requirements, or feedback in a structured way - Create surveys, questionnaires, or data collection forms with different field types - Kick off automated workflows based on what people submit ### Exploring documentation options Want to dive deeper? Check out the sidebar for everything you need to know about each template type: [^1]: Rules use if-then logic based on kick-off form responses to dynamically modify workflow paths [^2]: Section locking ensures regulatory compliance by preventing edits to approved legal or policy text - **[Compliance](https://tallyfy.com/products/pro/compliance/)**: Tallyfy provides SOC 2 Type 2 certified enterprise security with comprehensive audit trails for regulated industries along with bank-level encryption and SSO enforcement options supported by continuous monitoring and strict access controls across financial healthcare manufacturing and infrastructure sectors. ## Security and compliance overview Tallyfy delivers SOC 2 Type 2 certified security with bank-level encryption, mandatory SSO options, and complete audit trails that meet regulatory requirements. As an [independent, profitable company](/products/pro/miscellaneous/about-tallyfy/), we invest heavily in security because your trust is our foundation. ### SOC 2 Type 2 certification Tallyfy maintains SOC 2 Type 2 certification. An independent auditor examines our security controls over a three-month period. - **Assessment Period:** Our audits cover rolling three-month periods with continuous assessment. - **Scope Coverage:** The assessment tested **Security** controls based on AICPA Trust Services Criteria[^1] (the gold standard for SaaS security). - **Independent Auditor:** Our independent audit firm handled the audit - they're tough, thorough, and don't miss a thing. - **Compliance Status:** We maintain continuous SOC 2 Type 2 compliance with annual renewals. :::note[Getting the SOC 2 report] Current customers and prospective clients operating under Non-Disclosure Agreements may request full compliance documentation through our Tallyfy sales or support channels. ::: ### Regulatory audit trail requirements Tallyfy tracks all workflow actions automatically, creating a complete audit trail showing who did what, when they did it, and what changed. #### Audit trail capabilities - **Complete Process Documentation:** Every step gets timestamped with user and outcome - **Immutable Record Keeping:** Once something happens, it's locked in stone. Nobody can delete or modify audit records (not even admins) - **User Activity Logging:** See exactly who clicked what button at 3:47 PM last Tuesday - it's all there - **Export Capabilities:** Generate audit reports for regulatory compliance - **Version Control:** Track all template changes with author and reason #### Regulated industries using Tallyfy **Financial Services Compliance:** - Asset management firms meeting SEC Rules 204-2 and 206(4)-7 - Banks complying with FINRA audit requirements - Insurance companies tracking every claim decision and approval **Healthcare and Life Sciences:** - Pharma companies following FDA 21 CFR Part 11[^2] - Clinical research teams meeting ICH E6(R3) standards for trial documentation - Medical device manufacturers proving ISO 13485 compliance with every design change - Healthcare IT maintaining those mandatory HIPAA audit logs **Manufacturing and Safety-Critical Industries:** - Auto manufacturers tracking every part change for IATF 16949:2016 - Aviation maintenance shops meeting FAA AC 145-9A compliance - Nuclear facilities following 10 CFR 50 Appendix B - Chemical plants meeting OSHA's Process Safety Management requirements **Infrastructure and Utilities:** - Power companies dealing with NERC CIP cybersecurity audits - Railroads documenting track inspections per 49 CFR 213 - Mining operations proving MSHA workplace examinations actually happened These organizations require complete documentation showing "who did what, when." For industry-specific details, see [industry-specific workflow applications](/products/pro/tutorials/industry-specific-workflow-applications/). ### PCI-DSS compliance considerations **Tallyfy itself is not PCI-DSS certified** as we don't process payment card data directly. However, you can use Tallyfy in PCI-compliant environments by: - **Never storing card data in Tallyfy** - Don't enter credit card numbers, CVV codes, or other sensitive payment data in form fields - **Using tokenization** - Store only tokenized references from your payment processor - **Implementing compensating controls** - Use Tallyfy's audit trails and access controls as part of your PCI compliance program - **Separating systems** - Keep payment processing separate from workflow management For organizations requiring PCI compliance, consult your QSA (Qualified Security Assessor) about using Tallyfy as part of your cardholder data environment. ### Security governance framework Tallyfy implements enterprise security principles across the platform: #### Identity and access management - **Principle of Least Privilege:** Users only access workflows relevant to their role - **Multi-Factor Authentication:** Required second factor authentication for all logins - **Access Reviews:** Annual permission audits for users, quarterly for admins - **Environment Segregation:** Complete separation between development, test, and production environments #### Single Sign-On enforcement Tallyfy can restrict authentication exclusively to your SSO provider. SSO-only mode provides: * All logins through your SSO provider only * Email-password authentication disabled organization-wide * Centralized user management through your identity provider To enable SSO-only mode, contact [Tallyfy support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/). :::note[Advanced SSO for AI Integrations] For organizations implementing AI workflows, [SSO integration with MCP servers](/products/pro/integrations/mcp-server/sso-authentication/) extends identity governance to AI-powered applications, ensuring centralized authentication across both traditional workflow systems and emerging AI tools. ::: #### Data security protocols - **Transport Layer Encryption:** TLS 1.2+ encryption for all data in transit - **Data-at-Rest Protection:** AES-256 encryption for stored data in AWS servers - **Tenant Isolation:** Complete data separation between organizations #### Operational security management - **Vulnerability Assessment:** Annual penetration testing plus automated security scanning - **Change Control Procedures:** All code changes require development, testing, review, and approval before production deployment - **Continuous Monitoring:** AWS CloudWatch and GuardDuty provide 24/7 system monitoring with immediate alerting - **Incident Response Framework:** Documented and tested security incident response procedures #### Third-party risk management - **Vendor Security Assessment:** Security vetting required for all vendors with regular reassessments - **Supply Chain Oversight:** Regular review of AWS SOC 2 reports and vendor security documentation. --- [^1]: American Institute of CPAs framework covering security, availability, processing integrity, confidentiality, privacy [^2]: Federal regulation for electronic records and signatures in pharmaceutical and medical device industries - **[Launching](https://tallyfy.com/products/pro/launching/)**: Tallyfy's process launching feature transforms reusable workflow templates into active trackable instances with specific assignments and deadlines that operate independently through multiple launch methods including manual API webhooks forms email triggers and magic links while allowing customization during launch and protecting running processes from template changes. ## Process launching in Tallyfy Launching transforms templates into active, trackable processes with specific assignments and deadlines. When you launch a process, you create a running instance that team members work on. Templates are reusable blueprints. Launched processes are specific instances executing those instructions. Each process operates independently with its own timeline, participants, and progress tracking. ### Why use process launching? Launching turns documented procedures into active work with tracking and accountability. Task assignments reach team members at the right time with context. ### Templates vs. processes * **Templates** - Reusable master workflow designs with standardized step sequences (e.g., "Client Onboarding" template) * **Processes** - Individual workflow instances executing template instructions for specific cases (e.g., "Coca-Cola Client Onboarding" launched today) Each process needs a unique name for tracking and monitoring multiple concurrent executions. :::note[Template vs. blueprint] In the Tallyfy app, we use the term **Template**. In the technical API documentation, the same concept is called a **Blueprint**. ::: Launch a process every time you need to run the workflow from a template. ### Key concepts #### Process independence from template changes Template modifications only affect future launches. Running processes continue with their original instructions - they won't change mid-flight. This protects active workflows while enabling continuous template improvement. :::tip[Adding tasks to running processes] You can always add extra one-off [tasks](/products/pro/tracking-and-tasks/tasks/) to a process *after* it has launched. You aren't limited to the steps defined in the original template. ::: #### Launch methods * **Manual launching** - From the Templates interface * **Automatic triggers** - API calls, webhooks, or scheduled automation * **Cascade launching** - When tasks in other processes complete * **Web form integration** - Through form submissions * **Email triggers** - Send messages to designated addresses * **Magic links** - External stakeholders can initiate without login #### How launch methods work together This diagram shows how all launch methods converge to create an active process from a template. [Diagram removed for brevity] **Diagram description:** This diagram demonstrates the six different methods available to launch a process from a master template in Tallyfy, with all paths converging to create a single active process instance. The visual structure emphasizes that regardless of the launch method chosen (manual, API, task trigger, web form, email, or magic link), the result is always the same: an independently running process with its own timeline and assignments. **What to notice:** - All six launch methods lead to the same outcome - an active process instance - Every launch method allows optional customization before the process starts - The template remains unchanged while each process runs independently with its own timeline #### Customization during launch When launching a process, you can: * Set a unique process name * Change task assignments * Adjust deadlines * Add guest participants * Fill in the kick-off form with relevant data Alternatively, [set up auto-naming](/products/pro/tracking-and-tasks/processes/edit-processes/how-can-i-auto-name-a-process-in-tallyfy/) to automatically generate process names from kick-off form field values. ## Next steps Learn how to manually launch a process for full control over process details. For automation, explore launch triggers that start workflows automatically based on external events. - **[Lists](https://tallyfy.com/products/pro/lists/)**: Lists in Tallyfy are centralized data tables that organizations can create once and reference across all templates and processes to eliminate redundant data entry while ensuring consistency and enabling powerful integrations with form fields variables and automations for scenarios like vendor directories product catalogs employee roles and approval hierarchies. ## Centralized data management with Lists Lists in Tallyfy enable organizations to create centralized collections of structured data that can be referenced and reused across templates and processes. Lists function as organizational reference tables ensuring consistent data entry while significantly reducing manual work and minimizing data entry errors. This centralized approach streamlines workflow creation and maintains data consistency across all business processes. By providing single sources of truth for recurring data, Lists eliminate redundancy and improve workflow reliability throughout your organization. :::note[Feature coming soon] Lists functionality is currently in development and will be available soon. This documentation section is being prepared in advance of the feature release. ::: ### Workflow efficiency improvements Lists eliminate the inefficient practice of repeatedly entering identical information across multiple workflows and processes. This reduces administrative overhead significantly. Instead of manually typing vendor names, product codes, approval hierarchies, or other recurring data, organizations create Lists once and reference them throughout all relevant workflows. This centralized approach reduces data entry errors, saves significant time, and ensures consistent standardized information usage across organizational processes. By maintaining single sources of truth for frequently used data, Lists enable scalable workflow automation while preserving accuracy and consistency across the entire organization. ### Integration with Tallyfy features Lists integrate smoothly with Tallyfy core functionality. This enhances automation capabilities while maintaining platform simplicity: - **Form fields** can automatically pull selection options from Lists, eliminating manual dropdown creation and ensuring current data accuracy - **Templates** can reference List data for consistent process setup and standardized workflow configuration across the organization - **Variables** can be automatically populated from List values, enabling dynamic content generation without manual intervention - **Automations** can use List data for sophisticated conditional logic and intelligent workflow routing based on standardized criteria This integration creates a powerful ecosystem where centralized data drives intelligent workflow automation. ### Common use cases Organizations typically use Lists for various data management scenarios: - **Vendor directories** - Store supplier information, contact details, and approval workflows for procurement processes - **Product catalogs** - Maintain item codes, descriptions, and pricing information for sales and inventory management - **Employee roles** - Define job titles, departments, and permission levels for organizational structure - **Location data** - Keep office addresses, regions, and local requirements for geographic workflows - **Approval hierarchies** - Set up management chains and escalation paths for decision-making processes - **Compliance requirements** - Store regulatory codes, standards, and procedures for adherence tracking These use cases demonstrate how Lists support diverse organizational data needs while maintaining consistency. ### Getting started with Lists When Lists becomes available, you'll be able to implement complete data management: 1. Create structured data tables with custom columns tailored to your organizational needs 2. Import existing data from spreadsheets or databases for seamless migration 3. Connect List data to form fields and template variables for dynamic content 4. Update Lists centrally to reflect changes across all processes automatically 5. Control access permissions for List viewing and editing based on role requirements Lists will provide a powerful foundation for data-driven workflows while maintaining the simplicity that makes Tallyfy easy to use across all organizational levels. - **[Settings](https://tallyfy.com/products/pro/settings/)**: Tallyfy settings are organized into Personal Settings that affect individual user experience and Organization Settings that impact all users with only administrators able to modify organization-wide configurations. ## Settings organization Tallyfy settings are organized into two main areas: * **Personal Settings**: These settings affect only your individual user experience. Personal settings include your profile picture, password preferences, email notification options, and language selection. Any [member](/products/pro/documenting/members/) can modify their own personal settings independently * **Organization Settings**: These settings affect everyone in your organization's Tallyfy account. Organization settings encompass billing management, member roles, security protocols, integrations, and general company-wide preferences. Only users with the **Administrator** role can modify most organization-wide settings ## What to configure next Depending on your specific role in the organization, explore one of these Tallyfy settings areas next: - If you're a regular team member, start with [Personal settings](/products/pro/settings/personal-settings/) to customize your individual Tallyfy experience and notification preferences - If you're an administrator, thoroughly review the [Organization settings](/products/pro/settings/org-settings/) to configure system-wide options that affect all users - For account managers, understanding [Billing settings](/products/pro/settings/billing/) is essential for effectively managing your Tallyfy subscription and costs - **[Tracking](https://tallyfy.com/products/pro/tracking-and-tasks/)**: Tallyfy provides two core tracking views in the left sidebar: Tracker View for monitoring entire running processes across your organization and Tasks View as a personal to-do list for individual assignments from workflows or standalone tasks. ## Tracking options in Tallyfy Tallyfy gives you two main ways to track work - both found in the left sidebar. Understanding [what a workflow is](https://tallyfy.com/what-is-a-workflow/) helps you get the most from these tracking features. * **Tracker View**: Shows all your running [processes](/products/pro/tracking-and-tasks/processes/) at a glance. Think of it as your bird's-eye view of everything happening across the organization. Perfect when you need to see which workflows are on track and which need attention * **Tasks View**: Lists every individual [task](/products/pro/tracking-and-tasks/tasks/) you need to complete - whether they're part of a process or just one-off assignments. This is your personal to-do list on steroids ### Why two different views? Simple. The Tracker view is for managers who need to monitor entire workflows. The Tasks view is for getting actual work done. It's like the difference between watching traffic flow from a helicopter versus driving on the street. Both perspectives matter - just at different times. Teams that track processes effectively complete work faster. Makes sense when you think about it - you can't improve what you can't see. - **[Getting started](https://tallyfy.com/products/pro/tutorials/)**: Tallyfy provides structured tutorials that guide users from initial workspace setup through template creation and process automation in under 30 minutes while offering industry-specific examples and adoption strategies for teams. ## Getting started with Tallyfy tutorials Start using Tallyfy in minutes by following our step-by-step tutorials. New to workflows? Our guide on [what is a workflow](https://tallyfy.com/what-is-a-workflow/) explains the fundamentals. Each guide walks you through essential Tallyfy workflow features - from creating your first template to launching automated workflows. You'll build practical skills that transform how your team works. **Time to first workflow**: 15 minutes **What you'll accomplish**: Create, launch, and track your first business process :::tip[Quick start - simplest possible workflow] **Feel overwhelmed?** Start with the absolute minimum: 1. Click **+ Create** → **Create Template** → **From scratch** 2. Add just 3 steps: "Review request" → "Approve/Deny" → "Notify requester" 3. Assign each step to yourself 4. Launch it once to see how it works 5. Then add complexity gradually Most successful users start simple and expand later. Don't try to build the perfect process on day one. ::: ### Tutorial learning path Follow these tutorials in order to master Tallyfy quickly. Each builds on the previous one - taking you from setup to your first automated workflow. 1. **Create an organization** - Set up your workspace and invite team members (5 minutes) 2. **Navigate Tallyfy** - Learn the dashboard, tabs, and key features (5 minutes) 3. **Create your first template** - Build a reusable process blueprint (10 minutes) 4. **Launch your first process** - Turn templates into trackable workflows (5 minutes) Complete all four tutorials in under 30 minutes. You'll have a working process that your team can use immediately. ### Core skills you'll master After completing these tutorials, you'll know how to: * **Build templates** - Create reusable blueprints that standardize any business process * **Assign work intelligently** - Route tasks to the right people based on roles or workload * **Track progress in real-time** - See exactly where each process stands and identify bottlenecks * **Automate routine decisions** - Set up if-then rules that handle repetitive work automatically * **Collaborate effectively** - Add comments, share files, and keep everyone aligned * **Scale globally** - Support teams in multiple languages with [translation features](/products/pro/integrations/azure-translation/global-workplace-language-requirements/) These skills apply to any department - HR onboarding, sales workflows, IT requests, compliance procedures, and more. ### Industry-specific use cases **Fire stations & emergency services**: Create inspection checklists for daily, weekly, and monthly apparatus checks. Teams complete checks on any device, and reports automatically email to officers. Perfect for maintaining compliance and safety standards. **Small business outsourcing**: Build repeatable weekly tasks for marketing and production that contractors can follow without training. Assign work to freelancers who see only their specific tasks - maintaining quality while you focus on growth. **Client service management**: Set up collaborative workflows where clients submit requests that automatically route to your team. Track project status, gather requirements, and deliver updates without endless email chains. ### Browse all tutorials by topic Find exactly what you need in our organized tutorial library. Whether you're setting up your first workflow or mastering advanced features, there's a guide for you. ### Getting your team to adopt Tallyfy **Struggling with team adoption?** Here's what works: 1. **Start small** - Pick one simple process that causes daily pain. Win quick. 2. **Show, don't tell** - Run the process yourself first. Let results speak. 3. **Make it mandatory** - Choose a process people MUST follow (expense reports, time off requests) 4. **Celebrate early wins** - Share time saved, errors prevented, bottlenecks removed 5. **Train champions** - Get one enthusiast per department. They'll spread adoption. 6. **Remove alternatives** - Phase out the old spreadsheet/email method gradually 7. **Track and share metrics** - "We saved 10 hours this week" motivates teams Most successful organizations see strong adoption when they start with a critical, painful process that affects everyone. ### Evaluating Tallyfy during your trial **Making the most of your trial period:** 1. **Pick a real process** - Don't use hypothetical examples. Choose an actual workflow you run weekly. 2. **Set success criteria** - Define what "working" means: Time saved? Errors reduced? Visibility improved? 3. **Test with real users** - Include the people who'll actually use it, not just managers 4. **Measure improvements** - Track how long the process takes before and after Tallyfy 5. **Try key features** - Test automations, guest users, notifications, integrations you'll need **Questions to answer during trial:** - Can we build our critical processes? (Try your top 3) - Will our team actually use it? (Get 3+ people to complete tasks) - Does it integrate with our tools? (Test Zapier, API, or webhooks) - Is the ROI clear? (Calculate hours saved per week) :::tip[Trial success indicators] You'll know Tallyfy fits if: team members ask "when can we add more processes?", you catch errors that usually slip through, or you stop asking "what's the status?" in meetings. ::: ### Next steps after tutorials Ready to go deeper? These resources help you unlock Tallyfy's full potential: * **[Templates guide](/products/pro/documenting/templates/)** - Master advanced template features like conditional logic and dynamic assignments * **[Automation rules](/products/pro/documenting/templates/automations/)** - Build sophisticated if-then workflows that run themselves * **[Integration options](/products/pro/integrations/)** - Connect Tallyfy with your existing tools via API or webhooks * **[Contact support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/)** - Get expert help when you need it Most users create their first production workflow within 24 hours. Start with the tutorials above - you'll be automating processes today. :::note[Practice as you learn] Follow along in your own Tallyfy account. Each tutorial includes real examples and screenshots - you'll build actual workflows that your team can use immediately. ::: - **[Integrations](https://tallyfy.com/products/pro/integrations/)**: Tallyfy integrates with existing business software through multiple methods including APIs webhooks middleware platforms email connections and AI agents allowing teams to automate data sharing trigger cross-platform actions and maintain system synchronization without manual copying and pasting. ## Connecting Tallyfy with other business systems ![Integrations overview visualized as Tallyfy at the center connected by flowing data streams to various business application icons arranged in a circle - representing the multiple ways to connect and automate across your software ecosystem](https://screenshots.tallyfy.com/illustrations/integrations-overview.jpeg) Tallyfy connects with your existing business software through multiple methods - from simple email integrations to sophisticated API implementations. Pick what works for your team. Got developers? Great. Prefer clicking buttons instead of writing code? That works too. ### Integration benefits Without integrations, you're stuck copying and pasting data between systems all day. Integrations automatically share information between systems, trigger actions across platforms, and keep everything in sync. ### Available integration methods | Integration Method | Technical Skill Required | Primary Benefit | Optimal Use Case | |------------------------|--------------------------|------------------------------------|-----------------| | Open API | High (Development) | Complete control, custom solutions | Developers building sophisticated custom integrations | | Webhooks | Medium (Configuration) | Real-time event notifications | Sending Tallyfy events to external systems | | Middleware Platforms | Low (No-code tools) | Connect multiple apps visually | Cross-app automation without coding | | BYO AI (Coming Soon) | Low (OAuth setup) | Use your AI subscription in tasks | Automate decisions and content generation | | Computer AI Agents | Medium (Setup) | Automate complex UI interactions | Legacy systems without APIs | | Native Integrations | Low (Configuration) | Plug-and-play app connections | Pre-built connections for popular platforms | | Email Integration | Very Low (Basic setup) | Universal compatibility | Basic connections and process triggering | | Analytics Integration | Medium (SQL/BI tools) | Deep workflow data insights | Business intelligence and reporting | | Chat Platform Tools | Low (App installation) | Task management within chat | Teams heavily using Slack/Teams | | Azure Translation | Medium (Azure setup) | Real-time content translation | Multilingual teams and global operations | | Open Source Resources | Medium-High (Development)| Code examples and community support| Developers seeking implementation guidance | | Idempotency Handling | Medium-High (Architecture)| Prevent duplicate operations | All API and webhook integrations requiring reliability | ### 1. Open API Integration The Tallyfy REST API gives developers complete control. With the API, you can: - Build custom applications that use Tallyfy workflow data and functionality - Exchange information bidirectionally between Tallyfy and external systems - Automate process management - launch, update, and monitor workflows programmatically - Manage user accounts, permissions, and organizational settings through code - Control all Tallyfy features through custom applications and scripts ### 2. Webhooks Webhooks automatically notify external systems the moment something happens in Tallyfy - task completed, process launched, you name it. Here's what you can do: - Receive instant notifications in external tools when tasks complete - Track process progress in other business systems - Automatically send form data from Tallyfy to downstream applications - Trigger actions in external systems based on Tallyfy events - Configure event filtering at template and step levels for targeted notifications :::tip[Webhook setup and testing] **Setting up webhooks**: Navigate to your template, click on any step, and add your webhook URL in the webhook field. Test using services like RequestBin or Webhook.site first. **Troubleshooting webhooks**: 1. Verify your URL is publicly accessible (not localhost) 2. Check that your endpoint returns a 200 status code 3. Look for webhook events in your server logs 4. Test with a simple service first before complex integrations 5. Remember webhooks fire when tasks complete, not when they're created **Triggering Tallyfy from external systems**: To launch processes from external forms or capture guest data: 1. Use the API's process launch endpoint 2. Pass form data as kick-off form values 3. Include guest email in the payload for auto-assignment 4. Webhooks can notify your system when process starts 5. Perfect for lead capture, onboarding automation, and external form integration ::: ### 3. Middleware Platforms Can't code? No problem. Middleware platforms like Zapier, Make, and Power Automate connect Tallyfy to thousands of business applications through visual, drag-and-drop interfaces. You can: - Use pre-built connections for popular applications without writing code - Create integrations using visual workflow builders - Transform data formats between different systems automatically - Build conditional logic (IF-THEN statements) for intelligent workflows - Rely on platform-managed updates and maintenance **Examples:** Zapier, Microsoft Power Automate, Make.com, Workato, Tray.io ### 4. BYO AI Integration (Coming Soon) [BYO AI (Bring Your Own AI)](/products/pro/integrations/byo-ai/) lets you connect your existing ChatGPT, Claude, or Microsoft Copilot subscriptions directly to Tallyfy. Your AI becomes a team member that can: - Automatically complete tasks based on context and instructions - Generate content like emails, reports, and summaries - Make decisions and route workflows intelligently - Analyze data and provide recommendations - Work within your existing AI subscription limits No separate AI costs. No prompt engineering skills needed. Just connect your subscription and let AI handle the repetitive work. **Popular middleware options:** - **[Zapier](/products/pro/integrations/middleware/zapier/)** - **[n8n](/products/pro/integrations/middleware/n8n/)** - **[Power Automate](/products/pro/integrations/middleware/power-automate/)** :::note[Choosing a Middleware Tool] Zapier is popular for simple links, but for more complex or higher-volume connections, tools like **Make.com** or **Microsoft Power Automate** are often more powerful and better value. If you have developers, using Tallyfy's [Open API](/products/pro/integrations/open-api/) directly gives the most control and flexibility. ::: ### 5. Computer AI Agents Remember that ancient software your company refuses to replace? The one with no API? Computer AI Agents can control it like a human would - interpreting screens, clicking buttons, and filling forms automatically. Perfect for: - Legacy systems without APIs or complex integration challenges - Dynamic web pages and interfaces that change frequently - Multi-step tasks requiring contextual understanding of screen content - Adapting to interface changes without code modifications - Systems where traditional API integration isn't feasible or cost-effective **Examples:** Claude Computer Use, Twin.so, Skyvern, Manus AI :::note[Starting with Computer AI Agents] Computer AI Agents work best for **short, bite-sized tasks** that are mundane and repetitive. Don't start with complex, goal-driven jobs as they can be expensive and unpredictable. Focus on simple data entry, form filling, or information extraction from legacy systems first. ::: ### 6. Native integrations built by Tallyfy Native integrations are pre-built connections Tallyfy maintains for specific platforms. Key features: - Official support and testing by Tallyfy - Simplified setup compared to custom integrations - Designed for common use cases - Automatic updates maintained by Tallyfy - Direct support from Tallyfy if issues arise ### 7. Email Integration Everyone has email, right? That's why email integration is brilliant: - Start processes by sending emails to dedicated Tallyfy addresses - Configure Tallyfy to send emails from your company's email server (Custom SMTP) - Use the Tallyfy Gmail add-on to manage tasks directly from your inbox - Connect with any standard email system - Set up quickly without technical expertise **Featured:** [Gmail plugin](https://workspace.google.com/marketplace/app/tallyfy/671710262095) for managing workflows in Gmail. ### 8. Analytics Connection Want to know where your processes get stuck? Tallyfy Analytics exports process data for deep analysis with business intelligence tools: - Query Tallyfy data using standard SQL (via Amazon Athena) - Connect reporting tools like Power BI, Tableau, and Looker - Build custom dashboards and reports - Identify process bottlenecks through performance analysis - Track historical data and trends over time ### 9. Chat platform integration (e.g., Slack) Your team lives in Slack? Keep them there. Connect Tallyfy to your chat platforms: - Create Tallyfy tasks directly from chat messages - Launch processes without leaving your chat app - Receive status updates posted to relevant channels - Link conversations to their related tasks - Increase team visibility on workflow progress **Featured:** [Slack plugin](https://go.tallyfy.com/api/functions/slack/oauth2/install) for managing tasks in Slack. ### 10. Azure Translation Services Got team members in Tokyo, Paris, and São Paulo? Azure Translation breaks down language barriers instantly: - Translate task instructions and comments in real-time - Enable team members to work in their preferred language - Allow each user to set individual language preferences - Leverage Microsoft's AI translation technology - Support global teams across language barriers - Meet [global workplace language requirements](/products/pro/integrations/azure-translation/global-workplace-language-requirements/) in different countries **Featured:** [Content translation](/products/pro/integrations/azure-translation/) for text entered by users. ### 11. Open source resources for developers Need code examples? Check out Tallyfy's [GitHub](https://github.com/tallyfy/api-support) repository: - Sample code for common integration tasks - Helper scripts and utilities - Technical implementation guides - Examples you can adapt for custom solutions ### 12. Idempotency handling for reliable integrations Here's a problem nobody talks about - duplicate events. When building integrations with [Tallyfy's API](/products/pro/integrations/open-api/) or [webhooks](/products/pro/integrations/webhooks/), you'll face this challenge: - Webhooks can fire multiple times for the same event (task completed, reopened, then completed again) - External systems might send duplicate API requests - Process-level webhooks generate many events requiring careful handling - Without idempotency, you risk duplicate records, incorrect data, or failed operations Learn [how to handle idempotency](/products/pro/integrations/handling-idempotency-in-webhooks-and-api/) and build it right the first time. :::note[Future Exploration: Interactive Email Actions] Tallyfy is also exploring future enhancements like [interactive email actions](/products/pro/integrations/interactive-email-actions/), which could allow users to complete certain tasks directly from within supported email clients like Outlook and Gmail. ::: ### 13. AI-powered code generation If your team has developers and clear requirements, AI can draft working integration code fast. Use AI generation when you want custom logic beyond middleware but need speed. **Why use it** - Working integration code in 10-20 minutes - Clear, maintainable structure with logging and error handling - Fits your preferred language (for example, Python or JavaScript) **How it works** 1. Write a precise specification of the workflow and data mappings 2. Use your AI assistant to generate code that calls Tallyfy's [Open API](/products/pro/integrations/open-api/) 3. Review, test, and deploy 4. Iterate as requirements evolve **Example scenario**: A logistics team needs shipping workflows that vary by weight, destination, and carrier. A developer describes the rules, generates Python code, and ships the first version the same day. :::tip[Start with AI, refine with developers] Use AI to scaffold 70-80% of the code, then have engineers polish and harden it. You get speed without sacrificing quality. ::: ### Choosing the right approach Ask these four questions: 1. **Do you have developers available?** Yes → API or AI. No → Middleware. 2. **Is this one-time or ongoing?** One-time → AI. Ongoing → Plan for who maintains it. 3. **How complex is the logic?** Simple if-this-then-that → Middleware. Complex → API or AI. 4. **What is your timeline?** Need it this week → Middleware or AI. Have a month → API for maximum control. ### Integration approach comparison matrix | Factor | Direct API | Middleware | AI Code Generation | |--------|------------|------------|-------------------| | **Technical skill required** | High (developers) | Low (no-code) | Medium (review code) | | **Setup time** | Days to weeks | Hours to days | Hours to days | | **Customization level** | Unlimited | Limited by platform | High | | **Ongoing maintenance** | Code updates needed | Platform manages | Code updates needed | | **Cost** | Development time | Monthly subscription | AI tool + dev time | | **Performance** | Fastest | Good | Fast | | **Best for** | Complex, high-volume | Standard workflows | Custom but quick | ### Can I combine multiple approaches? Absolutely. Many teams mix and match: - **Middleware + API**: Keep simple automations in middleware while sending high-volume or complex work direct to the API - **AI + Middleware**: Let AI build lightweight endpoints, then wire them up via middleware - **Phased approach**: Start with middleware for speed, then migrate heavy-duty parts to API later :::note[Migration is always possible] You're never locked in. Start with middleware to get value quickly, then move to direct API when scale or complexity grows. ::: ## Recommended next Pick your path: - **Have developers?** Start with the [Open API](/products/pro/integrations/open-api/) for maximum control and customization. - **Prefer no-code?** Explore [Middleware platforms](/products/pro/integrations/middleware/) to connect Tallyfy without writing code. - **Need insights?** Set up [Analytics connections](/products/pro/integrations/analytics/) for custom reporting and dashboards. - **Move fast?** Use AI-powered code generation to scaffold an [API integration](/products/pro/integrations/open-api/) and iterate. - **[Miscellaneous](https://tallyfy.com/products/pro/miscellaneous/)**: Tallyfy provides comprehensive additional features and resources including company information browser compatibility details system features like file storage and search support documentation legal information and supplementary tools that enhance workflow management capabilities beyond core functionality. ## Additional Tallyfy features and resources This section covers diverse topics and features that enhance your Tallyfy experience beyond core workflow functionality. These additional resources give you essential support information, system compatibility details, and supplementary features that optimize your workflow management capabilities. Use the navigation below or on the left to explore topics like: - Learning [about Tallyfy](/products/pro/miscellaneous/about-tallyfy/) as a company and why customers trust us. - Getting **[Support](/products/pro/miscellaneous/support/)** and troubleshooting common issues. - Which browsers and devices work best with Tallyfy. - Details about system features like file storage, search, shortcuts, and [translation](/products/pro/miscellaneous/how-can-i-translate-content-in-tallyfy/). - Finding your [organization ID](/products/pro/miscellaneous/how-to-find-your-tallyfy-ids/), staying updated, and learning about partnerships. - Finding legal information like Terms of Service and Privacy Policy. Browse all articles using the navigation tree below: - **[Pricing](https://tallyfy.com/products/pro/pricing/)**: Tallyfy offers transparent workflow automation pricing with annual and monthly billing options featuring Full and Light member tiers plus a credit-based billing system for flexibility along with global accessibility discounts through their Fair Price Guarantee program and specialized nonprofit pricing. ## Workflow platform pricing Tallyfy delivers flexible business process management pricing models specifically designed for scalable workflow automation across organizations of all sizes. Our pricing structure focuses on transparency and value, letting businesses predict costs while scaling their workflow automation capabilities. As an [independent, sustainable company](/products/pro/miscellaneous/about-tallyfy/), we maintain fair, predictable pricing without surprise increases. Current detailed pricing information is available at the official page: https://tallyfy.com/pricing/. ### Subscription billing options **Annual Subscription Benefits**: Advance payment for twelve-month subscription periods provides significant cost savings compared to monthly billing cycles. Annual subscriptions give you budget predictability while maximizing cost efficiency for organizations committed to long-term workflow automation success. ### License tier structure Tallyfy offers differentiated user licensing models optimized for diverse organizational workflow management requirements and budget considerations. This tiered approach lets organizations assign appropriate access levels while controlling costs effectively: | Member Type | Annual Cost | Key Ability | |-----------------|------------------|--------------------------------------------------| | **Full Member** | See Pricing Page | Complete template creation, editing capabilities plus full task execution access. | | **Light Member**| See Pricing Page | Task completion access without template development permissions, ideal for process followers. | *(Note: Full Members include both Administrator and Standard roles).* :::tip[Save costs with roles] Assign **Full Member** licenses only to workflow designers who need template development capabilities. Give cost-effective **Light Member** licenses to operational staff focused solely on process execution and task completion. ::: :::note[Tallyfy Analytics add-on] * The optional [Tallyfy Analytics](/products/pro/integrations/analytics/) business intelligence service incurs supplementary annual fees per active user. * Analytics functionality requires **annual** Tallyfy subscription commitment. * It applies to **every** active member in your account. ::: :::note[What's included for free?] All paid Tallyfy subscriptions include: Unlimited guests, Single Sign-On authentication, AI-powered workflow features, personalized support consultations, and 14-day evaluation periods. Extended trial access remains available through [Tallyfy support channels](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/). Public template sharing capabilities incur no additional charges. ::: ### Credit-based billing system Tallyfy implements an innovative credit-based billing mechanism for annual subscriptions. This provides maximum flexibility and cost control for growing organizations. This intelligent billing system operates as a prepaid account balance, ensuring fair and transparent pricing: * **Prepaid Balance System**: Functions as a credit account that manages subscription changes automatically * **Smart Credit Consumption**: User additions or service upgrades consume available credits before triggering new payment card charges * **Pay for Active Users Only**: Billing applies exclusively to active team members, eliminating waste * **Proportional Refunds**: Mid-subscription user removals generate proportional credit refunds for unutilized subscription periods * **Credit-First Additions**: Mid-term user additions prioritize existing credit consumption before generating additional charges * **Credit Expiration**: Credits expire per billing terms and are not refundable to maintain system integrity ### Global accessibility pricing Tallyfy's Fair Price Guarantee program provides organizations in eligible countries with substantial discounts. These discounts are carefully calibrated to regional economic indicators including GDP per capita metrics. This accessibility initiative democratizes workflow automation technology, ensuring global organizations can access enterprise-grade process management regardless of local economic conditions. To apply: **Why lifetime pricing matters**: - **No surprise increases**: Your discounted rate never changes - **Budget predictability**: Plan long-term without worrying about price hikes - **Grows with you**: Add users at the same discounted rate as you scale - **Inflation protection**: Your costs stay flat while value increases :::caution[Payment method for Fair Price Guarantee] Payment instruments must originate from banking institutions within qualified countries to maintain discount eligibility. For example, Indian companies must pay with Indian bank cards or accounts. ::: ### Nonprofit organization pricing Certified nonprofit organizations may qualify for specialized pricing consideration. Details are available through the [Nonprofit Discount program](/products/pro/pricing/how-to-apply-for-tallyfys-nonprofit-program-discount/) documentation. ### Free and trial options Tallyfy offers several options for organizations exploring workflow automation or with limited budgets: **Free Plan Options**: - **14-day free trial**: Full feature access for evaluation (extendable through support) - **Free downgrade option**: Available for cost-conscious users who need basic functionality - **Trial extension**: Contact support to extend your evaluation period if needed **How to downgrade to free**: If subscription costs become challenging, contact support to discuss downgrading to a free account rather than canceling entirely. This preserves your data and templates while reducing costs. :::tip[Before canceling] Always ask support about downgrade options first. Many users don't realize a free tier exists - downgrading keeps your work accessible while eliminating monthly costs. ::: ### Advanced workflow capabilities Organizations can access powerful workflow platform capabilities: * Multilingual interface support (Included) * AI-powered content localization (Azure integration required, usage-based billing) * SOC 2 compliance attestation (Available upon request) * Dedicated support channel configurations * Serverless automation functions (Advanced workflow capability) ### Workflow consulting services Tallyfy offers specialized implementation consulting including: * Custom workflow template development services. * Advanced [API integration](/products/pro/integrations/open-api/) implementation. * Organizational change management and user adoption strategies. [Schedule consultation](https://tallyfy.com/booking/) to explore customized pricing or specialized implementation services. According to [industry analysis](https://www.gartner.com/reviews/market/business-process-management-platforms), business process management platforms increasingly focus on SaaS pricing models that offer predictable costs and scalable implementations. ### Compliance - **[BIMI compliance](https://tallyfy.com/products/pro/compliance/bimi-compliance/)**: BIMI authentication protects users from phishing attacks by displaying a verified company logo next to legitimate emails through multiple security layers including SPF DKIM and DMARC checks combined with a certified logo verification system that blocks fraudulent emails and makes fake messages immediately identifiable by their missing logo indicator. You know that little logo that appears next to emails from trusted companies? That's BIMI - and yes, Tallyfy uses it to protect you from phishing attacks. When you see our verified logo in your inbox, you can trust that email actually came from us. No logo? Not from Tallyfy. ### How does BIMI authentication work? Think of BIMI as a bouncer at an exclusive club - but for emails. It checks multiple forms of ID before letting our logo appear next to our messages. Here's the security check process (it's actually pretty clever): ### What user security benefits does BIMI provide? You're probably wondering what's in it for you. Fair question! Here's how BIMI makes your life easier (and safer): * **Enhanced Trust and Security:** See our logo? It's really us. No logo on an email claiming to be from Tallyfy? Delete it - it's fake. This visual cue takes about 0.1 seconds to check but saves you from potentially catastrophic phishing attacks. * **Streamlined Recognition:** Ever scroll through 200 emails looking for that one important message? Our logo makes Tallyfy emails pop out instantly. Users report finding our emails much faster. * **Reinforced Brand Familiarity:** You see our logo regularly in your inbox. Over time, your brain automatically associates it with legitimate Tallyfy communications. It's like muscle memory for email safety. ### How does BIMI provide cyber threat protection? Let me share some real examples of attacks BIMI stops cold (we see attempted attacks weekly, and they all fail): * **Domain Spoofing Prevention:** Someone tries to send you a "password reset" email from a fake tallyfy.com address. Their email? No logo. Yours? Straight to spam. Our authentication blocks countless spoofing attempts. * **Phishing Attack Mitigation:** Picture this - you get an urgent "Update your payment method NOW!" email. But wait... no Tallyfy logo? That's your red flag. Real urgent emails from us always have our verified logo. Always. * **Brand Impersonation Resistance:** Scammers can copy our website design, but they can't fake our BIMI certificate (trust me, they've tried). BIMI significantly reduces successful phishing attempts by making fraudulent emails immediately identifiable. ### What should I know about custom SMTP settings? :::caution[Using custom SMTP disables BIMI benefits] When you configure Tallyfy to send emails via your **own email server (Custom SMTP)** instead of Tallyfy servers (`tallyfy.com`), the BIMI logo **will not appear** on those emails. Why? Simple - the emails come from *your* servers, not ours. It's like putting a Ferrari badge on a Honda. Email providers check where the email actually originated, and when they see it's not from our servers, no logo appears. You'd need your own BIMI setup (which involves getting your own $1,500/year certificate). ::: Want the security benefits of our verified logo? Stick with our default email settings. Your IT team will understand. [^1]: Email authentication protocols that verify sender identity and message integrity [^2]: Verified Mark Certificate issued by certificate authorities to validate logo ownership - **[HSTS compliance](https://tallyfy.com/products/pro/compliance/hsts-compliance/)**: HSTS (HTTP Strict Transport Security) is a security protocol that forces browsers to use only encrypted HTTPS connections with Tallyfy and the platform is preloaded into major browsers meaning users receive protection from eavesdropping and man-in-the-middle attacks before they even visit the site for the first time. HSTS forces your browser to use encrypted connections only - it's Tallyfy's way of saying "no unencrypted data allowed here." Think of it as a security bouncer that blocks any attempt to connect without proper encryption. Once your browser talks to Tallyfy, we tell it: "From now on, always use HTTPS with us, even if someone tries to trick you into using regular HTTP." ### How do transport layer security protocols work? Here's what happens behind the scenes. When you first visit Tallyfy over **HTTPS**, we send your browser a special instruction called the `Strict-Transport-Security` header. It's like giving your browser a permanent note that says "Always use encryption when talking to Tallyfy - no exceptions!" Your browser remembers this instruction for a really long time (we set it for two years[^3]). Even if you accidentally type `http://` instead of `https://`, your browser catches this mistake before sending any data. Smart, right? ### What is Tallyfy's HSTS implementation strategy? We've taken HSTS a step further. Tallyfy is on something called the **HSTS preload list[^1]** - basically, we're hardcoded into Chrome, Firefox, Safari, and other major browsers. What does this mean for you? Your browser already knows to use HTTPS with Tallyfy **before you even visit us for the first time**. There's no window of vulnerability, not even for a millisecond. You're protected from day one. That's serious security. ### What security advantages does HSTS provide for users? Let's talk about what this actually protects you from. You might be thinking "Why all this fuss about HTTPS?" Here's why it matters: * **No more eavesdropping:** Remember those movie scenes where hackers intercept data? HSTS stops a nasty trick called **SSL stripping[^2]** where attackers try to downgrade your secure connection. If you accidentally click an old `http://` link to Tallyfy, your browser automatically upgrades it to HTTPS before sending anything. No data leaves your computer unencrypted. * **Your login stays safe:** All those session cookies that keep you logged in? They're transmitted only over encrypted connections. This matters big time when you're on public Wi-Fi at a coffee shop. Nobody can steal your session and pretend to be you. * **Everything stays private:** Every click, every form submission, every document you view - it's all encrypted. Period. Network admins, ISPs, or that person at the next table can't see what you're doing in Tallyfy. * **Peace of mind:** When you see that padlock icon, you know we're following the same security standards as your bank. It's not just marketing speak - it's real protection. ### How does HSTS mitigate cyber attacks? Here's how HSTS blocks the bad guys: * **SSL Stripping Attacks:** You know when hackers try to force your connection back to plain HTTP? Can't happen. HSTS locks you into encrypted mode before any data leaves your device. * **Man-in-the-Middle Exploits:** Those sophisticated attacks where someone sits between you and Tallyfy, pretending to be us? HSTS shuts them down cold. Your browser won't accept anything but our verified, encrypted connection. * **Session Hijacking:** Your authentication tokens and login cookies? They only travel over encrypted channels. No exceptions. Ever. #### Real-life example: Public Wi-Fi Picture this: You're at Starbucks, connecting to Tallyfy on their Wi-Fi. Someone else on that network is running hacking tools (happens more than you'd think). They try an SSL stripping attack - basically attempting to intercept your connection and force it to plain HTTP. Here's the beautiful part: Even if you accidentally type `http://tallyfy.com`, your browser says "Nope!" It remembers our HSTS policy and upgrades to HTTPS before sending a single byte. The hacker gets nothing. You don't even know an attack was attempted. That's the power of HSTS preloading. ### What are HSTS requirements and why do they exist? To make HSTS work properly, we follow seven strict rules. Here's what they are and why each one matters: 1. **Valid TLS/SSL Certificate:** This proves we're actually Tallyfy, not some imposter. Think of it as our digital ID card that browsers verify before trusting us. 2. **Automatic HTTPS Redirection:** If you somehow land on an HTTP page, we instantly redirect you to HTTPS. This ensures you get that protective HSTS header through a secure connection. 3. **Everything Uses HTTPS:** Every image, script, and resource loads over HTTPS. No exceptions. Otherwise, you'd get those annoying "mixed content" warnings - and potential security holes. 4. **Secure Header Delivery:** The HSTS instruction itself comes through HTTPS only. Why? Because if we sent it over plain HTTP, attackers could modify it. That would defeat the whole purpose. 5. **Long Memory (One Year Minimum):** We tell browsers to remember our HSTS policy for at least a year. Even if you don't visit Tallyfy for months, you're still protected when you come back. 6. **All Subdomains Protected:** Whether you're on app.tallyfy.com or api.tallyfy.com, HSTS covers everything. One policy, total protection. 7. **Browser Preload List:** We've opted into the ultimate protection - being hardcoded into browsers themselves. New users get HSTS protection before they even know we exist. These aren't just arbitrary rules. Each requirement closes a specific security gap. Together, they create an airtight system that keeps your data safe. Proper HSTS implementation significantly reduces the risk of man-in-the-middle attacks. [^1]: A Google-maintained list of sites hardcoded into browsers, eliminating first-visit vulnerability [^2]: Attack technique that forces HTTPS connections to downgrade to unencrypted HTTP [^3]: Max-age value of 63072000 seconds in the Strict-Transport-Security header ### Launching - **[Edit before launch](https://tallyfy.com/products/pro/launching/how-can-i-edit-a-process-before-launching/)**: Tallyfy allows users to customize process instances during launch by modifying the process name task assignees deadlines and guest details while preserving the original template for future use. ## How can I edit a process before launching in Tallyfy? When [launching](/products/pro/launching/) Tallyfy processes from [templates](/products/pro/documenting/templates/), the platform enables instance-specific customizations without modifying the original template structure. This pre-launch customization capability ensures each Tallyfy process instance can be tailored to specific requirements while preserving template integrity for future use. ### What elements can I customize before launching processes? The launch screen provides full customization options enabling process personalization for specific execution requirements: * **Process name**: Give this instance a unique name (e.g., "Onboard John Smith" instead of just "Employee Onboarding"). * **[Task](/products/pro/tracking-and-tasks/tasks/) assignees**: Change task assignments for this instance. * **Task deadlines**: Adjust task deadlines for this instance. * **[Guest](/products/pro/documenting/guests/) details**: Add or update guest email addresses if the template uses guest assignments. :::tip[Auto-naming for consistent process names] Instead of manually naming each process, you can [set up auto-naming](/products/pro/tracking-and-tasks/processes/edit-processes/how-can-i-auto-name-a-process-in-tallyfy/) to rename the project with values input in the fields automatically. This creates dynamic project names that pull data directly from your required kick-off form fields, ensuring consistent naming without manual effort. ::: ### How to edit before launching ![](https://screenshots.tallyfy.com/tallyfy-demo%2fpro%2fdesktop-light-edit-process-before-launch.png) :::tip[Tip for testing] If you want to test a process without sending notifications to the usual assignees, use this screen to temporarily assign all tasks to yourself. This lets you run through the process steps without bothering your team. ::: Remember, these changes only affect the process you are launching now. The original template is unchanged for future use. - **[Launch manually](https://tallyfy.com/products/pro/launching/how-can-i-launch-a-process-in-tallyfy/)**: Manual process launching in Tallyfy transforms reusable templates into active workflow instances by clicking Launch Process on template cards and providing unique names to ensure complete step tracking and customization control throughout workflow execution. ## Manually launching a process To launch a process from a template (called "Blueprint" in the API), click **Launch Process** on the template card and give it a unique name. Templates are reusable blueprints, while processes are the actual running instances you track. Manual process launching in Tallyfy starts new workflow instances that ensure every step is considered each time a process runs - so nothing is missed. Based on existing templates with smart process capabilities, launching gives you complete control over timing and customization. Manual launching offers the most flexibility for initiating smart processes that will ask for user input and modify the flow based on that input. Here's the complete step-by-step guide for manual process launching in Tallyfy: This approach makes sure each workflow instance is properly configured to track all elements as part of a larger workflow, preventing problems later. ### Why manual process launching matters Manual launching gives you essential Tallyfy process initiation control, ensuring every step is considered before workflow execution begins. This prevents problems later by allowing careful review and customization. While automated triggers offer efficiency benefits, manual launching lets you verify that smart processes are configured to ask for the right user input and modify their flow appropriately. This approach is particularly valuable for workflows with integrated client-facing forms and tasks that need human judgment for initiation timing. Mastering manual launching builds foundational understanding of how Tallyfy ensures nothing falls through the cracks in your workflows. ### Viewing hidden steps in running processes When smart processes utilize conditional rules to hide workflow steps initially (based on user input), Tallyfy provides viewing options to ensure every step is considered, even those not currently active: *Note: Even if you show hidden tasks, you usually can't see descriptions or form fields until rules activate them.* ### Modifying processes after launching Tallyfy enables post-launch process modifications to ensure every step remains considered even as requirements change. This prevents problems later by maintaining process integrity while providing flexibility. Process modification capabilities ensure smart workflows can continue to ask for user input and modify their flow based on new circumstances: ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-change-deadlines-ongoing-process.png) ### Adding ad-hoc tasks to running processes Unforeseen workflow requirements may necessitate additional steps to ensure nothing is missed. Tallyfy supports ad-hoc task addition to running processes, allowing you to maintain complete tracking as part of your larger workflow. Ad-hoc tasks ensure that even unexpected requirements are tracked and considered, preventing problems later while maintaining full workflow visibility: You can add any type of task (regular, approval, email, expiring) this way. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-add-task-to-ongoing-process.png) :::tip[Learn more about ad-hoc tasks] See [Add tasks to active processes](/products/pro/tracking-and-tasks/processes/edit-processes/how-can-i-add-tasks-to-active-processes-on-tallyfy/) for more details. ::: ## Next steps After learning how to manually launch processes, you might want to explore how to edit a process before launching for more customization options. If you need to automate process launching based on certain events, check out how to launch another process when a task is completed. These advanced capabilities enable more sophisticated workflow automation and management. - **[Launch on a schedule](https://tallyfy.com/products/pro/launching/how-can-i-schedule-a-process-in-tallyfy-using-middleware/)**: Tallyfy processes can be automatically launched on recurring schedules using middleware platforms like Zapier Make or Power Automate by setting up a schedule trigger that connects to Tallyfy's Launch Process action. ## How to schedule recurring Tallyfy process launches using middleware Tallyfy doesn't have a built-in scheduler to start processes automatically on a schedule (e.g., every Monday). However, you can easily do this using a [middleware](/products/pro/integrations/middleware/) tool like Zapier, Make, or Power Automate. This guide shows the basic steps using Zapier as an example - the process is similar in other [middleware platforms](/products/pro/integrations/middleware/). ### What you need * A Tallyfy account with the process [template](/products/pro/documenting/templates/) you want to schedule. * An account with a middleware service (like Zapier, Make, Power Automate). * Your Tallyfy account connected to your chosen middleware service. ### How to set it up using Zapier (example) #### 1. Choose the schedule trigger In Zapier, start a new Zap. For the trigger, search for and select the 'Schedule by Zapier' app. ![](https://screenshots.tallyfy.com/zapier-schedule-1.gif) #### 2. Set your schedule Set when the process should launch automatically: * Choose the frequency (e.g., Every Day, Every Week, Every Month). * Choose the specific day (e.g., Monday) or date (e.g., 1st of the month). * Set the time of day. ![](https://screenshots.tallyfy.com/zapier-schedule-2.gif) #### 3. Add the Tallyfy action For the action step, choose the **Tallyfy** app. Choose the 'Launch Process' action. ![](https://screenshots.tallyfy.com/zapier-schedule-3.gif) #### 4. Configure the process launch details Configure which Tallyfy process to launch and how: * Select the specific Tallyfy **Template** to use. * Set how the new process instance should be **Named**. It's best to include the date so each instance is unique (e.g., "Weekly Report - `{{zap_meta_human_now}}`"). Zapier provides variables like `{{zap_meta_human_now}}` to insert the current date/time. * Fill in other required details needed to launch that specific template. ![](https://screenshots.tallyfy.com/zapier-schedule-4.gif) #### 5. Test and turn on Test your Zap to ensure it launches the process correctly in Tallyfy. Name your Zap and turn it on. ![](https://screenshots.tallyfy.com/zapier-schedule-5.gif) Now, Zapier will automatically launch the Tallyfy process on the schedule you set - without manual effort each time. - **[Launch from a form](https://tallyfy.com/products/pro/launching/how-to-launch-a-tallyfy-process-from-a-webform/)**: External web forms can automatically trigger Tallyfy processes by redirecting users to special launch URLs with form data appended as query parameters that match the internal field names in your Tallyfy kick-off form template. ## Starting a Tallyfy process from a web form submission You can set up an external web form (like on your website, or using Typeform or Google Forms) so that when someone submits it, a Tallyfy [process](/products/pro/tracking-and-tasks/processes/) starts automatically - answers from the form fill in specific Tallyfy [fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) automatically. This saves time and avoids manual data entry. ### What you need * A Tallyfy account with permission to launch processes. * An external web form (e.g., Typeform, Google Forms, your website form). * A Tallyfy [process template](/products/pro/documenting/templates/) with [kick-off form fields](/products/pro/launching/triggers/kick-off-forms/) that have the *exact* same internal names as the fields in your web form (or the names you will send in the URL parameters). ### How to set it up #### 1. Prepare your Tallyfy template #### 2. Set up the web form / link The goal is to make your web form's "submit" action redirect the user to a special Tallyfy launch URL - adding the form answers to the end of the URL. #### Example URL If your Tallyfy template kick-off link is `https://example.tallyfy.com/launch/xyz` and your template has kick-off fields named `customer_name` and `customer_email`, the final URL your web form should send the user to might look like: ```text https://example.tallyfy.com/launch/xyz?customer_name=John%20Doe&customer_email=john.doe%40example.com ``` When the user visits this URL, Tallyfy will automatically start the process and pre-fill the `customer_name` field with "John Doe" and the `customer_email` field with "john.doe@example.com". - **[Troubleshooting permissions](https://tallyfy.com/products/pro/launching/troubleshooting-launch-permissions/)**: This guide explains how to troubleshoot and resolve common issues when launching processes in Tallyfy including permission errors for Standard members group assignment behaviors Magic Link failures with kick-off forms dropdown field mapping problems in Power Automate and API integration permission errors. ## How to resolve common process launch problems When launching processes in Tallyfy, you may encounter permission errors or unexpected behaviors. This guide helps you troubleshoot and resolve the most common launch-related issues. Standard members need explicit LAUNCH permission from an Administrator to start processes from templates. Group assignments behave differently when combined with automatic launcher assignment settings. Understanding these behaviors prevents confusion and ensures smooth process launches. ### Why can't a Standard member launch a process? **Problem**: A Standard member sees a template but gets an error when trying to launch it. **Cause**: Standard members don't automatically have permission to launch processes. Unlike Administrators who can launch any template, Standard members need explicit LAUNCH permission. **Solution**: 1. Have an Administrator edit the template 2. Go to **Config** > **Permissions** 3. Enable LAUNCH permission for the specific Standard member or "All Members" 4. Save the template **Prevention**: When creating new templates, immediately set appropriate launch permissions based on who should start processes from that template. ### Why is the process launcher being added to group assignments? **Problem**: When a process is launched with steps assigned to groups, the launcher appears as an additional assignee alongside the group. **Cause**: The "Assign launcher automatically" setting is enabled in the Advanced tab of those steps. This setting adds the launcher to any unassigned or group-assigned tasks. **Solution**: 1. Edit the template 2. For each step assigned to a group, click the **Advanced** tab 3. Turn OFF "Assign launcher automatically" 4. Save the template **Alternative approaches**: - Use specific member assignments instead of groups for steps where you don't want the launcher involved - Use automation rules to dynamically control assignments based on process data - Create a separate "Process Owner" role using job titles if you need the launcher involved in specific steps only ### Why do Magic Links fail with kick-off forms? **Problem**: Magic Links don't work when trying to launch processes that have kick-off forms with required fields. **Cause**: Magic Links attempt to launch processes directly without displaying the kick-off form interface. If the form has required fields, the launch fails because those fields aren't provided. **Solutions**: 1. **Make fields optional**: If appropriate, change required fields to optional in the kick-off form 2. **Use API with complete data**: Make API calls that include all required field values in the request 3. **Use public forms**: Share public kick-off form links for external users to fill out manually 4. **Use middleware**: Configure Power Automate, Zapier, or other middleware to provide all required values programmatically ### Why can't I map dropdown fields correctly in Power Automate? **Problem**: Dropdown field values from Tallyfy don't map correctly to other systems in Power Automate. **Cause**: Tallyfy dropdown fields return JSON objects with multiple properties (`id`, `text`, `value`), not simple text values. **Solution**: 1. Add a **Parse JSON** action after getting Tallyfy data 2. Use expressions to access the specific property you need: - For display text: `body('Parse_JSON')?['fieldName']?['text']` - For the ID: `body('Parse_JSON')?['fieldName']?['id']` 3. Handle null values with conditional expressions **Example Power Automate expression**: ``` if(empty(body('Parse_JSON')?['dropdownField']), '', body('Parse_JSON')?['dropdownField']?['text']) ``` ### How do I handle permission errors in API integrations? **Problem**: API calls to launch processes return permission errors even with valid credentials. **Cause**: The API user (associated with the API key) must have permission to launch the specific template. **Solutions**: 1. **Use Administrator API keys**: Generate API keys from an Administrator account for full access 2. **Grant specific permissions**: If using a Standard member's API key, ensure they have LAUNCH permission for the template 3. **Check template permissions**: Verify the template isn't restricted to specific members only 4. **Test with user credentials**: Try launching the process manually with the same user account to verify permissions ### Best practices for avoiding launch issues **Template configuration**: - Document which roles should launch each template - Set permissions immediately when creating templates - Test launch permissions with different user roles before deployment - Use descriptive names for job titles to avoid confusion during launch **Group assignments**: - Decide whether launchers should be included in group tasks - Configure "Assign launcher automatically" consistently across similar templates - Consider using automation rules for complex assignment logic **Integration setup**: - Test Magic Links with sample data before widespread use - Document field mapping requirements for middleware integrations - Use Parse JSON actions in Power Automate for all Tallyfy data - Maintain a test template for verifying integration permissions **Communication**: - Train Standard members on which templates they can launch - Document any special launch procedures or requirements - Create a permissions matrix showing who can launch what - Establish a process for requesting launch permissions These practices help prevent common issues and ensure smooth process launches across your organization. - **[Launch another process when a task is completed](https://tallyfy.com/products/pro/launching/launch-process-when-task-is-completed/)**: Tallyfy enables workflow automation by allowing users to configure specific tasks within templates to automatically launch new processes or inject tasks from other templates upon completion through the Advanced tab settings. ## How to automatically start another Tallyfy process when a task is completed ### What you need * Permission to edit Tallyfy [templates](/products/pro/documenting/templates/). * At least two templates: one ("trigger") with the task that starts the action, and another ("target") that you want to launch automatically. * An understanding of how the processes should link together. ### Overview: Linking Tallyfy processes together Tallyfy lets you set up a link so that when a specific [task](/products/pro/tracking-and-tasks/tasks/) in one process finishes, it automatically starts a new [process](/products/pro/tracking-and-tasks/processes/) based on a different template. This workflow automation is useful for complex processes broken down into multiple templates (like project phases). ### When to use this * **Multi-phase projects**: Finishing Phase 1 automatically starts the Phase 2 process. * **Customer journeys**: Finishing the "Sales" process automatically starts the "Onboarding" process. * **Branching workflows**: Completing an "Initial Review" task might launch either an "Approved Project" process or a "Further Review" process. * **Team hand-offs**: Finishing a task by Sales automatically launches a process for Operations. ### How to set it up ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-launch-process-when-task-completed.png) ### Option: Inject tasks instead of launching new process Instead of starting a separate new process, you can insert the tasks from the target template directly into the current running process. This effectively moves a template inside another template at runtime, combining multiple workflow components into a single active process. :::note[What "inject tasks" does] Injecting tasks adds all steps from the target template into the current process instance, right after the trigger task. Everything stays within the same process, just with added steps. This keeps related work connected in one place and effectively moves the entire target template inside your running process. ::: ### Which templates can be launched/injected? The dropdown list for the target template only shows templates that: * Are active (not archived). * Have **no** required [kick-off form fields](/products/pro/launching/triggers/kick-off-forms/) (as there's no user present to fill them in during automatic launch). * You have permission to launch. :::warning[Can't find your template?] If the template you want isn't listed, check if it's active, has no required kick-off fields, and that you have launch permissions for it. ::: ### Naming the automatically launched process You can control the name of the new process launched automatically: 1. Use the default name: "Month day - hh:mm - Template Name". 2. Create a custom name using text plus data [variables](/products/pro/documenting/templates/variables/) from the *trigger* process's kick-off form. 3. Click the `{}` button to insert available variables from required kick-off fields. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-custom-naming-process.png) ### Limitations (advanced) * **Naming variables**: You can only use variables from required kick-off form fields of the *trigger* process when customizing the *launched* process name. * **Passing data**: There isn't currently a built-in way to automatically pass data from the trigger process to fields in the launched process (other than via the name). For complex data transfer, consider using the Tallyfy [API](/products/pro/integrations/open-api/) or [webhooks](/products/pro/integrations/webhooks/) with [middleware](/products/pro/integrations/middleware/). * **Referencing data**: You cannot easily reference data between original and injected tasks when using injection. ### Tracking the connection Tallyfy automatically links the trigger and launched processes: 1. The launched process gets hidden tags identifying the trigger process and task. 2. The Tallyfy Bot adds a comment to the trigger task, including a link to the newly launched process. ![](https://screenshots.tallyfy.com/tallyfy/pro/desktop-light-show-bot-comment.png) This helps you see connections and check the automation worked. - **[Triggers](https://tallyfy.com/products/pro/launching/triggers/)**: Tallyfy offers seven flexible process launch triggers including manual buttons API calls email triggers magic links scheduled automation task completion chains and kick-off forms to accommodate different organizational needs and technical capabilities while enabling automatic data pre-population for seamless workflow initiation. ## Process launch triggers Triggers are the different ways a process can be started (launched) in Tallyfy for workflow automation. Some triggers are manual (a person clicks a button), while others are automatic - starting a process based on an event or schedule. This flexibility enables organizations to initiate workflows in ways that align with their specific operational needs and technical capabilities. ### Prerequisites * A Tallyfy account with permission to launch processes for security compliance. * Process templates ready to launch with complete configuration. * A clear understanding of how you want your processes to start based on business requirements. These prerequisites ensure successful trigger implementation and proper workflow automation. ### Available trigger methods Tallyfy provides several flexible ways to start processes based on organizational needs: * **Manual Launch**: A user clicks the 'Launch Process' button in Tallyfy for direct, simple initiation. * **API Trigger**: Another system uses code (the Tallyfy API) to tell Tallyfy to start a process, enabling seamless integration with other business software. * **Email Trigger**: Sending an email to a specific Tallyfy address automatically launches a process, useful for starting workflows without logging into the platform. * **Magic Links**: Clicking a special web link ('magic link') launches a process with the ability to share or embed links and pre-fill data automatically. * **Schedule Trigger**: Using middleware (like Zapier or Power Automate), you can schedule automatic launches (e.g., daily, weekly) for recurring workflows. * **Task Completion Trigger**: Completing a specific task in one process can launch another process, enabling seamless workflow chaining. * **Kick-off Form**: Filling out a form (public or internal) launches the process while often pre-filling data from the form submission. These diverse trigger options accommodate different automation scenarios and technical skill levels. ## Process trigger flow visualization This diagram shows how all seven trigger methods converge to launch a process in Tallyfy. [Diagram removed for brevity] **What to notice:** - All seven trigger methods ultimately lead to the same outcome - launching a process - Some triggers (API, Magic Links, Forms) can automatically pass data to pre-fill process fields, while manual launch cannot - The mix of manual and automatic triggers provides flexibility for both technical and non-technical users ### Sending data automatically when launching Some triggers let you send data automatically when the process starts, eliminating manual data entry: | Trigger Type | How Data is Sent | |-------------------|------------------------------------------------------| | API Triggers | Include data in the API call code. | | Magic Links | Add data as URL parameters to the web link. | | Email Triggers | Tallyfy can sometimes extract data from the email body.| | Web Forms | Pass form data via URL parameters. | | Kick-off Forms | Form data directly fills fields in the process. | This saves time and reduces errors by avoiding re-typing data. ### Choosing the right trigger Consider these factors when selecting a trigger method: - What event should start the process (a person, another system, a schedule) based on your workflow requirements? - Do you need to send data automatically when it starts to reduce manual work? - What technical skills are available on your team for implementation and maintenance? - How often will the process run and what volume of launches do you expect? These considerations help ensure you select the most appropriate trigger method for your specific organizational needs and technical capabilities. See the specific articles in this section for detailed setup instructions for each trigger type. ### Triggers - **[Launch via a kick-off form](https://tallyfy.com/products/pro/launching/triggers/kick-off-forms/)**: Kick-off forms in Tallyfy attach to process templates to collect essential information before workflows begin and can be shared publicly for external stakeholders to initiate processes while automatically launching trackable workflows upon submission. ### Prerequisites for kick-off form setup - Permission to edit Tallyfy templates. - A process template where you want to add a starting form. - Clear understanding of what information you need to collect before the process starts. ## Kick-off forms for process launching Kick-off forms attach to the beginning of Tallyfy templates, ensuring information collection before main workflow tasks commence. These forms accommodate both internal team usage and public access - enabling external stakeholders including customers or partners to initiate processes through form submission. Unlike standalone online forms, Tallyfy kick-off forms integrate directly with subsequent workflow steps. Upon form submission, processes launch immediately with progress tracking across all participants. ### Creating a kick-off form ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-how-to-add-kickoff-forms.png) ### Available field types You can use various field types to capture different types of information: * Short Text (for names, IDs, brief responses) * Long Text (for descriptions, detailed explanations) * Dropdown List (pick one from a predefined list) * Checklist (pick multiple from a list) * Radio Buttons (pick only one option) * Date (for scheduling) * File Upload (for documents, images, attachments) Mark fields as Required if the process cannot start without that information. Note: Having required fields limits how the process can be started automatically (e.g., cannot be started by email or some API calls without providing the required data). ### Completing kick-off forms When someone launches a process that has a kick-off form: ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-launch-kickoff-form.png) ### Accessing kick-off form answers Anyone working on the process can see the information submitted in the kick-off form: This helps provide context for later tasks. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-show-kickoff-on-task.png) :::note[Filling forms automatically] You can pre-fill kick-off forms automatically using data from other systems, often via [web form links](/products/pro/launching/how-to-launch-a-tallyfy-process-from-a-webform/) or middleware. ::: ### Public kick-off forms You can share a kick-off form publicly so anyone (even non-Tallyfy users) can fill it out to start a process. #### Benefits of public forms * **Starts workflow automatically**: No delay between form submission and process start. * **Submitter tracking link**: The person who submits gets a unique, permanent link to track the progress (if they verify their email). * **Email verification**: Helps prevent fake submissions and allows Tallyfy to send updates to the submitter. * **Save and return**: Submitters can save partly filled forms and come back later using their link. * **No extra tools needed**: Directly integrates form submission with your Tallyfy process. #### Important note on deactivated members and public forms If the Tallyfy member associated with setting up the public form gets deactivated, it can affect the public link. Always check and potentially reassign public forms before deactivating members to avoid issues. (See [Removing Members](/products/pro/documenting/members/how-can-i-remove-a-member-from-my-tallyfy-organization/) for details). :::caution[Magic Links limitation with kick-off forms] Magic Links cannot be used to pre-fill kick-off form data when the form has required fields. This is because Magic Links work only for logged-in users and process directly without displaying the kick-off form interface. For external users or when you need to pre-fill forms with required fields, use: - Public kick-off form links for external users - Web form redirects with query parameters - API calls with proper field data - Middleware integrations that can programmatically provide required field values ::: ### Making kick-off forms public ### Public form submission process When someone clicks the public link: This is great for forms that might take time to fill out. ### Public forms vs. internal process steps **Public Kick-off Forms**: - **Who sees them**: External users (customers, vendors, partners) without Tallyfy accounts - **Purpose**: Collect initial information to start a workflow - **Access**: Via public link shared through email, website, or other channels - **User experience**: Simple form interface with your company branding - **What happens next**: Form submission automatically creates a process inside Tallyfy **Internal Process Steps**: - **Who sees them**: Your team members and assigned guests - **Purpose**: Execute the actual workflow tasks after the process starts - **Access**: Through Tallyfy dashboard with login credentials - **User experience**: Full task management interface with comments, attachments, and tracking - **Visibility**: External submitters can track overall progress but cannot see internal task details :::tip[Common Use Case: Purchase Requisitions] A vendor submits a purchase order through your public form. This automatically creates an internal approval workflow where your finance team reviews, approves, and processes the order - all invisible to the vendor except for status updates. ::: ### Best practices for kick-off forms #### Progressive Information Gathering Kick-off forms should follow a "minimal upfront, progressive collection" approach: - **Only include guaranteed available information**: Ask only for data the person launching will have at the start - **Avoid complex conditional questions**: Save detailed branching questions for later workflow steps - **Keep initial forms lightweight**: Don't overwhelm users with extensive forms - **Plan for just-in-time data collection**: Design subsequent workflow steps to gather additional information when it's needed :::tip[Equipment Insurance Example] Instead of asking "List all equipment details, specifications, and carrier requirements" in the kickoff form, start with just "Is this endorsement for equipment or facilities?" and "What's the client ID?" Then use conditional automations to reveal appropriate detailed collection steps based on those initial answers. ::: #### Form Design - **Use clear field names** without technical jargon - **Arrange fields logically** - **Mark fields as required sparingly**: Only if the process cannot proceed without that information - **Provide helpful guidance text** for fields that need extra explanation - **Test thoroughly** before sharing widely #### Advanced Progressive Collection Techniques - **Conditional step revelation**: Use [automations](/products/pro/documenting/templates/automations/) to show additional data collection steps based on kickoff form responses - **Role-based information requests**: Collect different information based on who is launching the process (department, expertise level, etc.) - **Just-in-time validation**: Verify and expand initial information at appropriate workflow milestones rather than upfront - **Exception path planning**: Design clear procedures for handling unusual situations that don't fit standard information collection patterns #### Common Mistakes to Avoid - **Front-loading complex questionnaires**: Asking for detailed information that may not be available until later in the process - **Branching in kickoff forms**: Complex conditional logic belongs in workflow steps, not initial forms - **Requiring uncertain information**: Making fields mandatory when the person launching may not have that data readily available - **One-size-fits-all approaches**: Not considering that different types of users may have different information available at launch time - **[Launch via a magic link](https://tallyfy.com/products/pro/launching/triggers/magic-links/)**: Magic links are special URLs that enable logged-in Tallyfy users to automatically trigger actions like launching processes completing tasks adding comments or updating form fields when clicked from emails websites or other tools. ## Magic links in Tallyfy ### Prerequisites * Access to Tallyfy Settings > Integrations > Magic Links (usually Admin only) * The ID of the template or task you want the link to affect * A basic understanding of web links (URLs) and parameters * Users clicking the link must already be logged into Tallyfy ### What are magic links? Magic links are special web links (URLs) that make Tallyfy automatically perform actions when a logged-in user clicks them. You can create links to: * Create a one-off task * Launch a process from a template (and pre-fill info) * Complete a specific task * Re-open a specific task * Add a comment to a task * Change a task's deadline * Update a form field value in a specific task They're useful for triggering Tallyfy actions from emails, websites, or other tools. :::caution[For internal users only] Magic links only work for users logged in to your Tallyfy organization. They **don't** work for external guests. To let external users start processes, use [public kick-off forms](/products/pro/launching/triggers/kick-off-forms/). ::: :::warning[Magic Links and required kick-off fields] Magic links cannot bypass required kick-off form fields. If your template has a kick-off form with required fields, the magic link will fail to launch the process because it attempts to start the process directly without displaying the form interface. For processes with required kick-off fields, consider: - Making kick-off fields optional if appropriate - Using API calls that can provide all required field data - Using public kick-off forms for manual data entry - Using middleware platforms that can programmatically supply required values ::: ### Access the magic link generator 1. Go to **Settings** > **Integrations**. 2. Click the **Magic Links** section. ### Available actions | Action | Description | |-----------------------------|--------------------------------------------------| | Create One-Off Task | Creates a standalone task. | | Launch Process | Starts a new process from a template. | | Complete Task | Completes a specific task. | | Re-open Task | Re-opens a completed task. | | Add Comment | Adds a set comment to a specific task. | | Edit Deadline | Updates the due date of a specific task. | | Update Form Field | Updates a form field value in a specific task. | ### Create magic links #### Launch a process 1. Go to the Magic Links section in Settings. 2. Click **Get a Magic Link**. 3. Choose **Launch a Process** from the dropdown. 4. Select the **Template** you want the link to launch. 5. Set options like the default **Process Name** (you can use variables). 6. You can also pre-fill data in [kick-off fields](/products/pro/launching/triggers/kick-off-forms/) by adding parameters (see structure below). 7. Copy the generated magic link URL. 8. You might need to add more parameters manually (e.g., adding field values). #### Create one-off tasks 1. Go to the Magic Links section. 2. Click **Get a Magic Link**. 3. Choose **Create a One-Off Task**. 4. Set the default task details (name, assignee, deadline - some can be overridden in the URL). 5. Copy the generated URL. ### Magic link structure for process launching A link to launch a process and fill in data follows this structure: ```text https://go.tallyfy.com/[YourOrgID]/process/[TemplateID]/create?default_run_name=Your+Process+Name&ko_fields=[{"fieldName1":"Value1"},{"fieldName2":"Value2"}]&launchprocess=true ``` * Replace `[YourOrgID]` and `[TemplateID]` with your actual IDs. * `default_run_name` sets the process name. * `ko_fields` contains the kick-off field names and values to pre-fill. * **Important**: Values must be [URL encoded](https://www.w3schools.com/tags/ref_urlencode.ASP) (e.g., spaces become `+` or `%20`). * **Important**: The `ko_fields` value needs JSON formatting `[{"field-name":"field-value"}]`, which must also be URL-encoded. #### Automatic naming If your template uses kick-off fields for auto-naming, you can use `auto` instead of the Template ID for dynamic naming: ```text https://go.tallyfy.com/[YourOrgID]/process/auto?ko_fields=[{"fieldName1":"Value1"}]&launchprocess=true ``` :::note[Auto-naming rules] - Only works if fields used for auto-naming are *required* kick-off fields. - The auto-generated name must be 550 characters or less. - When using magic links with auto-naming, all required fields must be provided in the `ko_fields` parameter, otherwise the process launch will fail. ::: ### Field value syntax When defining values for the `ko_fields` parameter, use this format (before you URL-encode it): | Field Type | Example JSON Value String | |-------------------|----------------------------------------------------------------------------------------| | Short/Long Text | `"Your Text Value"` | | Dropdown | `{"id":ID,"text":"Selected Label","value":null,"required":true}` (Get ID/Label from template editor) | | Checkbox | `[{"id":ID,"text":"Checked Label","value":null,"required":false,"selected":true}]` (List of checked labels/IDs) | | Radio Button | `"Selected Radio Value"` | | Date/Time | `"YYYY-MM-DDTHH:MM:SS.mmmZ"` (`UTC` format) | ### Examples of other actions (Replace placeholders like `[YourOrgID]`, `[TaskID]`, values, etc. with your actual values) * **Create Task:** `...?action=createOotTask&default_task_name=Review+Doc` * **Complete Task:** `...?action=completeTask&task_id=[TaskID]` * **Re-open Task:** `...?action=reOpenTask&task_id=[TaskID]` * **Add Comment:** `...?action=writeAComment&task_id=[TaskID]&comment=Please+review` * **Edit Deadline:** `...?action=editDeadline&task_id=[TaskID]&deadline=YYYY-MM-DD+17:00:00` * **Update Form Field:** `...?action=updateFormFieldValue&task_id=[TaskID]&form_fields={"fieldId123":"New+Value"}` ### Where to use magic links - Buttons or links in emails (e.g., "Click here to approve task") - Links on your company intranet - Buttons or links generated by other tools (like your CRM) - QR codes for mobile-friendly workflow initiation - **[Launch via API](https://tallyfy.com/products/pro/launching/triggers/via-api/)**: Tallyfy's REST API enables automated process launching through code integration with external systems by authenticating via API key or OAuth and sending POST requests with template IDs and kick-off form data to create processes triggered by events like CRM deal closures or IoT sensor alerts. ## Launching processes via API ### Prerequisites Before starting, make sure you have: - A Tallyfy account with API access enabled - API authentication credentials (API key or OAuth token) - The ID of the template(s) you want to launch - A basic understanding of REST API concepts and JSON ### API workflow automation Tallyfy's REST API lets you start processes automatically using code. You can integrate with other systems and build custom ways to launch processes based on external events or conditions. ### Implementation steps 1. **Get authentication details** - Generate an API key (or set up OAuth) in your Tallyfy account settings - Store credentials securely 2. **Find the process template ID** - Locate the Template ID (e.g., from the URL when viewing the [template](/products/pro/documenting/templates/)) - Note any [kick-off form fields](/products/pro/launching/triggers/kick-off-forms/) that need data 3. **Build the API request** - Use the `/api/processes` endpoint with a `POST` request - Include authentication headers - Format the request body (**JSON**) with the template ID and process details 4. **Handle the response** - Get the Process ID from a successful response - Add error handling for failed requests See the [API Process Launch Guide](/products/pro/integrations/open-api/code-samples/processes/launch-process) for full details. ### API features Launching via the API offers: #### Automation capabilities - Start processes based on events in other systems - Schedule repeating process launches - Start many processes at once (bulk launch) #### Data integration - Fill kick-off form fields with external data - Send complex data structures into processes - Link Tallyfy processes to records in other systems (like a CRM) #### Process customization - Use custom process names - Control task assignments via code - Set custom deadlines using logic ### Sample API request ```json POST /api/processes HTTP/1.1 Host: go.tallyfy.com/api Authorization: Bearer YOUR_API_TOKEN Content-Type: application/json { "template_id": "your-template-id", "name": "API Triggered Process - Customer Onboarding", "kickoff_fields": { "customer_name": "Acme Corporation", "contract_value": 15000, "start_date": "2024-01-15T00:00:00.000Z" } } ``` ### Common use cases API launching works well for: - Connecting a CRM to start customer onboarding when new deals close - Starting approval workflows from document management systems when documents are uploaded - Starting inspection processes from IoT devices when sensors trigger alerts - Creating processes from external form submissions - Starting workflows from database changes - **[Email triggers](https://tallyfy.com/products/pro/launching/triggers/via-email/)**: Email triggers allow teams to launch Tallyfy processes by sending emails to template-specific addresses where the email subject becomes the process name and content can be automatically captured into kick-off fields if configured. ### Prerequisites * Permission to edit templates. * No required kick-off form fields in the template (optional fields are fine). * Email must be sent from an active member's address. ### Launching processes via email Send an email to a template's unique address to start a process without logging into Tallyfy. Useful for mobile users or when working from external systems. :::warning[Cannot use with required kick-off fields] This email trigger method **doesn't work** if the template has any kick-off form fields marked as **Required**. You'll get an email saying the launch failed. Only use templates with optional (or no) kick-off fields if you want to launch them via email. ::: ### Setting up email triggers Each template gets its own unique email address for launching. ### Email trigger workflow When someone sends an email to that special Tallyfy address: 1. Tallyfy checks if the sender's email belongs to an active member in your organization. 2. If yes, Tallyfy starts a new process from the template linked to that address. 3. The email's Subject becomes the Name of the new process instance. 4. If you added special kick-off fields (see below), the email content copies into them automatically. 5. Assignees for the first task(s) are notified to begin work. ## How does the email trigger process work automatically? This diagram shows the complete email trigger flow, including all validation checks and possible outcomes. [Diagram removed for brevity] **What to notice:** - The sender must be an active member in your organization - emails from external addresses or inactive members are automatically rejected - Templates with required kick-off fields cannot be launched via email - you'll receive a failure notification if you try - Email content and attachments are only captured if you've specifically added `email_body` or `email_attachments` fields to your template's kick-off form ### Capturing email content You can have Tallyfy automatically save the email body and attachments into kick-off form fields. Add kick-off fields to your template with these specific internal names: | Field Name | What it Captures | Recommended Field Type | |-------------------------|-----------------------------------|------------------------| | `email_body` | The full text of the email body | Long Text Area | | `email_attachments` | Any files attached to the email | File Upload | If you don't have these fields, Tallyfy might show a link to create them when you enable the email trigger. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-create-email-fields.png) ### Email address format The trigger email address follows this format: ```text bot+[TemplateID]-launch@tallyfy.com ``` (Where `[TemplateID]` is the unique ID of your template) ### Example uses * **Field Updates**: Technicians email status updates after site visits (Subject: Site Visit - Client X; Body: Details; Attachments: Photos). * **Forwarding Requests**: Support forwards an email to the trigger address to start a complaint process. :::caution[Consider structured forms instead of email triggers] While email triggers work, we strongly encourage moving away from email-based process launching. Why? Emails are unstructured - you get whatever people decide to write, in whatever format they choose. This creates data quality issues and makes automation difficult. **Better approach**: Use [kick-off forms](/products/pro/launching/triggers/kick-off-forms/) instead. With structured forms: - You get the exact data fields you need, every time - Data arrives in consistent formats (dates, numbers, dropdowns) - Required fields ensure nothing critical is missed - Validation prevents errors before the process starts - Integration with other systems becomes seamless Email triggers should be your fallback option, not your primary method. Transform unstructured email chaos into structured, predictable workflows. ::: ### Smart email forwarding with keywords You can trigger Tallyfy processes from your regular email conversations by using a special keyword that your email system detects and forwards automatically. **How it works:** 1. Include a unique keyword like `TRIGGER-TALLYFY` anywhere in your regular emails (to customers, colleagues, etc.) 2. Set up an email rule/filter in your email system (Gmail, Outlook, etc.) that: - Searches for emails containing your keyword - Automatically forwards matching emails to the Tallyfy template address - Optionally removes the keyword before forwarding 3. The process launches automatically when Tallyfy receives the forwarded email **Example scenario:** You're emailing a customer about their order. By including `TRIGGER-TALLYFY` in your email, your email system automatically forwards it to launch a "Customer Follow-up" process in Tallyfy - all without sending a separate email or leaving your inbox. **Benefits of this pattern:** - Trigger processes during normal email conversations - No need to remember Tallyfy email addresses - Creates documentation in both your email and Tallyfy - Works with any email system that supports rules/filters - Can use different keywords for different templates (e.g., `TRIGGER-ONBOARDING`, `TRIGGER-COMPLAINT`) **Setting up the email rule (Gmail example):** 1. Go to Gmail Settings > Filters and Blocked Addresses 2. Create filter: "Has the words: TRIGGER-TALLYFY" 3. Action: Forward to `bot+[TemplateID]-launch@tallyfy.com` 4. Optional: Also apply label for tracking ### Security considerations * The sender must be an active Tallyfy member in your organization. * Use clear email subjects (they become the process name). * Each template has a unique trigger email. * Cannot launch templates with required kick-off fields via email. ### Adding comments via email replies You can also add comments to existing tasks by replying to the Tallyfy task notification email. (The reply-to address for comments looks like `bot+[TaskID]-comment-task@tallyfy.com`) ### Best practices - Keep a list of trigger emails for your team. - Suggest standard subject formats for easier tracking. - Remind users to put details in the body if you're capturing it. - Test the trigger from different email clients your team uses. - **[Launch via middleware](https://tallyfy.com/products/pro/launching/triggers/via-middleware/)**: Middleware platforms enable automatic Tallyfy process launches by watching for events in external applications and seamlessly transferring data to create workflows without manual intervention or coding requirements. ## How can I launch Tallyfy processes using middleware for seamless automation? ### What prerequisites are needed for middleware-based process launching? * A Tallyfy account with permission to launch Tallyfy processes for workflow automation. * An account with a middleware platform (e.g., Make.com, Power Automate, Zapier) for integration capabilities. * A Tallyfy process template to launch automatically with complete configuration. * Access to the system (e.g., CRM, form tool, database) that will trigger the launch for data source connectivity. These requirements ensure successful middleware integration and automated workflow initiation. ### How does middleware integration work for Tallyfy workflow automation? Middleware tools act like a bridge between Tallyfy and other software systems. They watch for an event in another application (the "trigger") and then automatically tell Tallyfy to start a specific process - often sending data too. This lets you start Tallyfy workflows based on outside events, without custom coding. This integration approach eliminates manual workflow initiation and creates seamless automation between disparate business systems. ### How does the middleware process launching workflow function? 1. **Connect**: Connect your middleware tool to Tallyfy and the other app using your account details for secure integration. 2. **Trigger**: Set up a trigger in the middleware – what event in the other app should start things? (e.g., "New contact added in HubSpot", "Form submitted in Typeform"). 3. **Map Data**: Tell the middleware how to map data from the trigger app to the fields in your Tallyfy kick-off form for proper data transfer. 4. **Launch Action**: Add an action in the middleware to "Launch Process" in Tallyfy, using the mapped data for automated execution. 5. **Run**: When the trigger happens, the middleware automatically launches the Tallyfy process with the data for seamless workflow initiation. This systematic approach ensures reliable and consistent process automation across different business systems. ### Visualizing the middleware integration flow This diagram shows how external applications trigger Tallyfy processes through middleware platforms. [Diagram removed for brevity] **What to notice:** - The middleware acts as a bridge, watching for events and translating between systems (steps 2-4) - Data mapping happens within the middleware before reaching Tallyfy (step 4) - The entire flow is automated - once configured, no manual intervention needed ### What capabilities does middleware provide for Tallyfy integration? Middleware makes it easy to create sophisticated automation: * Start Tallyfy processes based on events in other tools (new CRM deal, calendar event, database update) for real-time workflow initiation. * Automatically send data from those tools into the Tallyfy process for seamless information transfer. * Automatically fill Tallyfy kick-off forms with external data for streamlined process setup. * Change data formats between systems if needed for compatibility and standardization. * Add logic (e.g., only launch the Tallyfy process if a certain condition is met in the other tool) for intelligent automation. These capabilities enable sophisticated business process automation without requiring custom development. ### How can I connect online forms for automated workflow initiation? Middleware is excellent for connecting form tools (like Google Forms, Typeform) to Tallyfy. When someone submits the form, the middleware can take the answers and use them to launch a Tallyfy process automatically. This integration transforms static form submissions into dynamic workflow initiation with all submitted data. | Form Tool | Connection Difficulty | Data Sent | |-------------------|-----------------------|-------------------| | Google Forms | Easy (Built-in Connector)| All form answers | | Microsoft Forms | Easy (Built-in Connector)| All form answers | | Typeform | Medium (Webhook) | All form answers | | Wufoo | Medium (Webhook) | All form answers | | Cognito Forms | Medium (Webhook) | All form answers | ### How should I choose the right middleware platform for my needs? * **Make.com (Recommended)**: Very flexible, good for complex mapping and advanced automation scenarios. * **Microsoft Power Automate (Recommended)**: Good choice if you use Microsoft 365 for seamless ecosystem integration. * **Zapier**: Simple, wide app support for straightforward automation needs. * **Pabbly**: Often affordable, good basic features for budget-conscious organizations. * **Workato / Tray.io**: More powerful, for enterprise/complex needs requiring advanced capabilities. Consider these factors when choosing: * How complex is the connection and data transformation requirements? * What is your budget for integration platform subscriptions? * Which apps do you use in your current technology stack? * How much data changing is needed for compatibility? * Team's technical comfort level with different platforms? These considerations ensure you select the most appropriate platform for your specific integration requirements. ### What are the general steps for setting up middleware integration? 1. **Plan**: Decide which event/app should trigger which Tallyfy launch based on your business requirements. 2. **Choose**: Select your middleware tool based on capabilities, budget, and technical requirements. 3. **Build**: Create the workflow/scenario: set trigger, add Tallyfy "Launch Process" action, map data appropriately. 4. **Test**: Test to ensure processes launch correctly with the right data and proper error handling. 5. **Activate**: Turn on your workflow/scenario and monitor for successful operation. This systematic approach ensures reliable middleware integration and successful automation deployment. See our [middleware integration guide](/products/pro/integrations/middleware/) for platform-specific setup instructions. - **[Launch via a schedule](https://tallyfy.com/products/pro/launching/triggers/via-recurring-schedule/)**: Tallyfy processes can be automatically launched on recurring schedules using middleware platforms like Zapier or Make.com as well as custom API-based solutions with server-side schedulers to run repeating workflows without manual intervention. ## Schedule recurring process launches ### Prerequisites - A Tallyfy account with the right permissions - Process templates ready for scheduled launch - Access to middleware platforms (like Zapier, Make.com) or API capabilities - Your schedule needs (daily, weekly, monthly) ### Benefits Automatic launches run repeating workflows (daily, weekly, monthly) on time without manual intervention. ### Implementation options ### 1. Middleware platforms Schedule through Zapier, Make.com, or Microsoft Power Automate. **Implementation steps:** **Example: Daily equipment check** ``` Trigger: Schedule (Every day at 8:00 AM) Action: [Launch](/products/pro/launching/) Tallyfy [process](/products/pro/tracking-and-tasks/processes/) Template: Equipment Safety Check Process name: Equipment Check - {date} ``` ### 2. API-based scheduling Build custom solutions using the Tallyfy API with server-side schedulers. **Implementation steps:** **Example: Node.js script** ```javascript const cron = require('node-cron'); const axios = require('axios'); // Schedule task to run at 9:00 AM every Monday cron.schedule('0 9 * * 1', async () => { try { await axios.post('https://go.tallyfy.com/api/processes', { template_id: 'your-template-id', name: `Weekly Report - ${new Date().toLocaleDateString()}` }, { headers: { 'Authorization': 'Bearer YOUR_API_TOKEN', 'Content-Type': 'application/json' } }); console.log('Weekly report process launched successfully'); } catch (error) { console.error('Failed to launch process:', error); } }); ``` ### 3. Integrated workflows Trigger from existing systems (ERP, HRIS) that already have scheduling capabilities. **Implementation steps:** ### Recommended approach Middleware schedulers are the simplest solution. See our Monthly Process Launch with Zapier guide for a detailed example. ### Common use cases | Process Type | Frequency | Example Implementation | |--------------|-----------|------------------------| | Compliance audits | Monthly | Schedule equipment inspection process on the 1st of each month | | Financial reporting | Weekly | Launch expense approval workflow every Friday at 4:00 PM | | Team updates | Daily | Trigger daily standup checklist each morning at 9:00 AM | | Maintenance checks | Quarterly | Schedule facility inspection process on the first day of each quarter | | Client reviews | Annually | Launch client satisfaction survey process on client anniversary dates | :::note[Process naming] For scheduled [processes](/products/pro/tracking-and-tasks/processes/), use consistent names that include the date/time for easier tracking. Example: "Monthly Compliance Check - January" ::: ### Tracking and tasks - **[Protect sensitive data](https://tallyfy.com/products/pro/tracking-and-tasks/how-can-i-protect-sensitive-data-in-tallyfy/)**: Sensitive information should be stored securely outside Tallyfy in dedicated systems with controlled access while using secure links within task descriptions to reference the data rather than storing it directly in the platform. ## Best practices for protecting sensitive information Never store sensitive data directly in Tallyfy - keep it in your secure systems and link to it instead. This protects confidential information while letting your workflows reference what they need. Got workflows that handle Social Security numbers, credit card details, or patient records? Here's the thing: you can't just drop that sensitive info into task descriptions or form fields. That's asking for trouble. ### Recommendations for handling sensitive data Here's what actually works: 1. **Store sensitive data securely outside Tallyfy**: Your confidential info belongs in dedicated secure systems - think encrypted databases, your existing HR platform, or that specialized finance software you're already using. These systems have the access controls you need. 2. **Limit access**: Only authorized users should touch the secure system where your data lives. Period. 3. **Don't put sensitive data directly in Tallyfy**: This one's critical. Never type or paste sensitive details into Tallyfy [task](/products/pro/tracking-and-tasks/tasks/) names, descriptions, or form fields. Not even once. 4. **Link securely**: Here's the smart move - add secure links in your Tallyfy task descriptions that point to where the data actually lives. Simple, right? ### How to link to sensitive data from Tallyfy Let me walk you through this (it takes maybe 2 minutes): 1. First, make sure your sensitive info is already stored securely in your other system. Don't skip this step. 2. Grab a secure link (URL) that lets *authorized users* access that specific data. Most systems can generate these. 3. Open the Tallyfy [task](/products/pro/tracking-and-tasks/tasks/) where you need to reference this data. 4. In the task description, explain what the data is and add your secure link. Something like: "Review the customer's credit application here: [secure link]" 5. Save the task description. Done. Your workflow can now reference the sensitive info it needs without actually storing it in Tallyfy. The data stays safe in your secure system, and your team can still access it when they need to. ### Collecting sensitive documents securely Need to collect sensitive documents from clients or external users? Use [file request links](mdc:products/pro/integrations/document-management/file-request-links/) from your document management system. This approach lets people upload directly to your secure DMS without the files ever passing through Tallyfy. Perfect for law firms, healthcare providers, and financial services where compliance matters. - **[Problems with flowcharts](https://tallyfy.com/products/pro/tracking-and-tasks/can-i-build-a-flowchart-in-tallyfy/)**: Tallyfy transforms static flowcharts spreadsheets and documents into dynamic executable workflows that provide real-time tracking automated task routing and centralized process management with permissions and notifications to ensure teams actually follow and complete their work efficiently. ## How Tallyfy compares to flowcharts, spreadsheets, and docs No, Tallyfy isn't for building flowcharts - it's something much better. You're looking for a way to actually run and track your processes, not just draw them. ### Why Tallyfy is better than flowcharts Sure, flowcharts can show you a process - but they can't actually *run* it. That's the problem. Here's what makes Tallyfy different: * **Includes everything you need**: Add detailed instructions, videos, and files right where people need them. No more hunting for that PDF guide. * **Shows you what's happening now**: See exactly where each process stands in real-time. Is John stuck on step 3? You'll know. * **Gets work to the right people**: Assign specific tasks with deadlines - and Tallyfy sends automatic reminders. * **People actually use it**: Unlike that flowchart gathering dust on the shared drive, this becomes a living workflow your team follows daily. ### Why Tallyfy is better than spreadsheets Anyone who's tried tracking processes in spreadsheets knows it gets messy fast. You've been there - multiple versions floating around, nobody updating their status, that one cell with the broken formula. Tallyfy fixes all that: * **Everything lives in one spot**: No more jumping between 15 different spreadsheets to track your processes. It's all here. * **You know who's doing what**: Each task shows exactly who's responsible. No more "I thought Sarah was handling that" moments. * **Steps happen in order**: The workflow follows your actual process - with smart rules that route tasks based on what happened before. * **People see only what they need**: Set permissions so contractors see their tasks while managers see everything. * **One version, always current**: Forget "Process_Tracker_v2_FINAL_FINAL_actually_final.xlsx" - everyone works from the same live workflow. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-create-client-onboarding-template-from-tallyfyAI.png) ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-click-create-template-by-tallyfyai.png) ### Why Tallyfy is better than documents Word docs and PDFs might work for storing information, but they're terrible for actually running processes. Think about it - when's the last time your team enthusiastically opened that 47-page procedures manual? Here's the difference: * **Find what you need instantly**: Instead of scrolling through pages, jump straight to the step you're on. Simple. * **Work from anywhere**: Phone, tablet, laptop - Tallyfy works on all of them. Your process follows you. * **Know who's actually following the process**: See who's viewed instructions, who's completed steps, and where things are stuck. Documents can't tell you any of that. * **It's alive**: This isn't a static document - it's an active workflow that guides people through each step, sends reminders, and tracks everything. ![Tallyfy dynamic workflow demonstration](https://screenshots.tallyfy.com/tallyfy/pro/tallyfy-dynamic-workflow-demo.gif) - **[Check notifications](https://tallyfy.com/products/pro/tracking-and-tasks/how-can-i-view-notifications-in-tallyfy/)**: Tallyfy users can access their notifications by clicking the bell icon in the top right corner which displays recent alerts in a dropdown with an option to view complete notification history for all updates assignments and comments. ## View notifications Click the bell icon (🔔) in the top right corner of Tallyfy to see your notifications. The dropdown shows recent alerts, and there's a link to view your complete notification history. You'll get notifications when someone assigns you a task, comments on your work, or when there's an update that needs your attention. Simple. ### How do I find my notifications? Look for the notification icon - it's a bell 🔔 in the top right corner of your Tallyfy screen. Got new notifications? You'll see a red dot or number on that bell. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-show-notifications.png) Click the bell and you'll see your recent notifications right away. ### How can I view all notifications? Want to see everything, including older notifications? Here's how: 1. Click the notification icon (🔔) in the top right corner. 2. In the dropdown that appears, click **VIEW ALL NOTIFICATIONS**. That's it. You're now looking at your complete notification history - every alert, update, and message in one place. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-show-all-notifications.png) - **[An overview of processes](https://tallyfy.com/products/pro/tracking-and-tasks/processes/)**: Processes in Tallyfy are running instances of templates that transform workflow blueprints into trackable work with unique names and activity logs while template changes don't affect already-running processes. ## Processes in Tallyfy A process is a running instance of a template - it's your Tallyfy [business process](https://tallyfy.com/business-process/) in action. Here's the key difference: * A **[Template](/products/pro/documenting/templates/)** is like a master recipe or blueprint for a standard workflow task (e.g., the steps for onboarding a new employee) * A **Process** is a *single time* you execute that template for a specific case (e.g., the actual onboarding process for *Jane Doe* that you started today) :::tip[Can't find where you added a task?] **Added a task but it disappeared?** You probably added it to a running process, not the template: - Tasks added to a **running process** only exist in that specific instance - Tasks added to a **template** will appear in all future processes launched from it - To update the template itself: Go to **Templates** tab → Edit your template → Add the task there - To add a task to just one process: Open that specific process → Use "Add Task" for one-off additions Think of it like this: Editing a recipe card (template) changes all future meals. Adding extra spice to tonight's dinner (process) only affects that one meal. ::: ### Why are workflow processes essential for business operations? Processes are the heart of getting actual work done in Tallyfy - they transform your templates into real, trackable workflows. Templates tell you how work should be done. Processes? They're the actual work happening right now. Understanding this distinction matters because: - Processes are what you track daily - Processes are where team members collaborate - Processes are how you measure real progress Clear processes with unique identities help prevent confusion, enable proper tracking, and provide valuable data for continuous improvements. Every time you need to execute the work defined in a template, you **[launch](/products/pro/launching/)** that template to create a new, unique process instance that you can track. This workflow approach applies to any repeatable business process, big or small. ## How should I name workflow processes? Give each launched process a unique, descriptive name so you can differentiate them (e.g., "Onboard Jane Doe", "Onboard John Smith"). This takes seconds but saves hours of confusion later. Want to save even more time? Set up **auto-naming** in Tallyfy template settings (`Settings > Summary > Auto-naming`). This feature automatically creates process names based on information entered in required kick-off form fields - the project names pull directly from the data users enter during process launch. :::note[Auto-naming rules] - Auto-naming only uses **required** kick-off [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/). - The generated name cannot be longer than 550 characters. - This dynamic project naming from field inputs ensures consistent, meaningful process names without manual effort. ::: ## What are the key characteristics of Tallyfy processes? * A process is a copy of its template *at the moment it was launched*. Later template changes? They won't touch processes already running :::important[Template updates don't affect running processes] **Critical limitation**: When you update a template, existing processes continue with their original version. This is by design due to three technical challenges: 1. **State determination**: No way to know where to insert new steps in a partially-complete process 2. **Relevance**: New steps might not apply to processes started under different conditions 3. **Step removal**: Can't safely remove completed steps that hold important data **Workaround for long-running processes** (like 6+ month sales cycles): - Use the "Add Task" feature to manually add new steps to running processes - Consider shorter process cycles with handoffs between templates - For major changes, complete existing processes and launch new ones This ensures data integrity but requires planning for processes that may need mid-flight updates. ::: * You can launch many processes from the same template * A process can be based on a [procedure template](/products/pro/documenting/templates/) (with workflow steps) or a [document template](/products/pro/documenting/documents/) (like a fillable form) * You can add extra one-off [tasks](/products/pro/tracking-and-tasks/tasks/) to a running process if needed * Each process has its own unique activity log (audit trail) for compliance tracking :::tip[Adding extra tasks] If something unexpected comes up, you can add new tasks (regular, approval, email, etc.) directly to a running process without changing the original template. See [Add tasks to active processes](/products/pro/tracking-and-tasks/processes/edit-processes/how-can-i-add-tasks-to-active-processes-on-tallyfy/). ::: :::note[Template vs. Blueprint] Reminder: In the Tallyfy app, we say **Template**. In the technical API documentation, it's called a **Blueprint**. ::: ## What happens when a process is completed? Completed processes remain visible in your Tracker view by default. Here's how to clean up your active views while preserving the data: - **Archive processes**: Click the three-dot menu (...) on any process card in the Tracker view - **View archived processes**: Filter by "Status = Archived" in the Tracker view - **Restore processes**: Unarchive them anytime if you need to reference them again Need step-by-step instructions? See [how to archive and unarchive processes](/products/pro/tracking-and-tasks/tracker-view/organize-processes/how-to-archive-and-unarchive-processes-in-tallyfy/). :::note[Archive vs. Delete] **Archiving**: Removes processes from active views but preserves all data for future reference and audit trails. Archived processes can be restored anytime. **Deleting**: Permanently removes the process and all associated data. This action cannot be undone. To delete a process completely, archive it first, then go to the archived view and select the permanent delete option. Use deletion sparingly - archiving is usually the better choice for maintaining historical records. ::: ## What should I learn next? You've got the basics of Tallyfy processes down. Ready to put them to work? Check out the [Tracker view](/products/pro/tracking-and-tasks/tracker-view/) to monitor workflow progress in real-time. Need to modify processes after launch? Learn how to [add tasks to active processes](/products/pro/tracking-and-tasks/processes/edit-processes/how-can-i-add-tasks-to-active-processes-on-tallyfy/) for maximum flexibility. - **[More about tasks](https://tallyfy.com/products/pro/tracking-and-tasks/tasks/)**: Tasks in Tallyfy are fundamental work units that come in two types - process tasks that are part of workflow templates and one-off tasks that function as standalone to-dos with steps in templates becoming tasks when processes are launched. ## What are tasks in Tallyfy? Tasks are the actual work items people complete in Tallyfy - they're what your team interacts with every day. Simple as that. You've got two types to work with: ### Why is understanding tasks important for workflow management? Here's the thing - tasks drive everything in Tallyfy. They're how work actually gets done. When you understand tasks, magic happens: - Your team knows exactly what to do (no more confusion or "what's next?" questions) - Work gets done right the first time - by the right people at the right time - Processes flow smoothly because everyone's on the same page - AI can help complete tasks automatically with [BYO AI integration](/products/pro/integrations/byo-ai/) The result? No bottlenecks. No dropped balls. Just smooth workflows. ### What timing concepts apply to tasks? Timing matters. Tallyfy gives you two ways to control when things happen: - **Start time**: When someone should start working on the task (it's guidance, not enforced - think of it as a friendly nudge) - **Deadline**: The hard stop. When the task must be done. Miss this and it shows as overdue You can set both timings whether you're creating templates or quick one-off tasks. Get this right and your team hits deadlines like clockwork. Pro tip: Use [expiring tasks](/products/pro/tracking-and-tasks/tasks/what-types-of-tasks-can-i-create-with-tallyfy/) for FYI items that auto-complete at deadline. This prevents [task debt](/products/pro/tutorials/how-to/how-to-avoid-task-debt/) - that overwhelming buildup of overdue work that never seems to go away. Now, about those task types I mentioned: 1. **Process Tasks**: These live inside your [process templates](/products/pro/documenting/templates/) - they're connected to other tasks and follow a specific workflow. This is where 90% of your work happens in Tallyfy. Perfect for anything you do repeatedly 2. **One-off Tasks**: Quick, standalone to-dos. No template needed. Just create it, assign it, done. Great for those "can you handle this?" moments that pop up ### What is the difference between tasks and steps? This trips people up, so let's clear it up right now: **Steps** live in templates. **Tasks** live in running processes. Think of it this way: * When you're building a [template](/products/pro/documenting/templates/), you add Steps - these are the blueprint. Each step has its own type (regular task, approval, email, you name it) * When you [launch](/products/pro/launching/) that template? Those steps transform into Tasks that people actually complete. Same types, different context. A Task step becomes a Task task, an Approval step becomes an Approval task Simple, right? For all the different types you can use, check out the [Step/Task Types article](/products/pro/tracking-and-tasks/tasks/what-types-of-tasks-can-i-create-with-tallyfy/). ## What should I learn next? Got the basics down? Great. Here's where to go from here. First up - dive into the [different types of tasks](/products/pro/tracking-and-tasks/tasks/what-types-of-tasks-can-i-create-with-tallyfy/) Tallyfy offers. There's more than you might think, and each type solves specific workflow challenges. Need something done fast? Learn how to [create a one-off task](/products/pro/tracking-and-tasks/tasks/how-to-create-a-one-off-task-in-tallyfy/). Takes 30 seconds, max. And when things go sideways (they always do sometimes), you'll want to know how to [report and resolve issues](/products/pro/tracking-and-tasks/tasks/how-to-report-and-resolve-issues-in-tallyfy/). Tallyfy's blocker system is a lifesaver for handling roadblocks. - **[Tracker view](https://tallyfy.com/products/pro/tracking-and-tasks/tracker-view/)**: The Tracker view in Tallyfy serves as a real-time dashboard that provides a centralized bird's-eye view of all running organizational processes with flexible display options smart filtering capabilities and comprehensive management actions to monitor progress spot bottlenecks and prevent issues before they become problems. ## The Tracker view The **Tracker** view provides a real-time dashboard of all running processes in your organization. You can monitor progress, spot bottlenecks, and ensure nothing gets overlooked - all from one centralized location. Unlike individual task management, the Tracker shows you the big picture. You see how processes connect, where work is flowing smoothly, and where attention is needed. This bird's-eye view helps you manage workloads and prevent issues before they become problems. ## Key features of the Tracker view ### Flexible display options Tallyfy offers two ways to visualize your processes: * **Board View**: Visual cards show each process with status indicators, assignees, and progress bars. Perfect for teams who prefer kanban-style organization. * **Table View**: A spreadsheet-like format displays processes in rows with customizable columns. Ideal for sorting, filtering, and bulk operations. Switch between views instantly based on your current needs. See [how to switch between board and table formats](/products/pro/tracking-and-tasks/tracker-view/how-to-switch-between-board-and-table-formats-in-tallyfy-tracker/) for step-by-step instructions. ### Smart filtering capabilities Focus on what matters most with powerful filters: - View only overdue processes - Show processes assigned to specific team members - Filter by template type or department - Display processes with active issues or blockers - Access archived processes for reference or restoration Save your favorite filter combinations for quick access later. ### Process management actions From the Tracker view, you can perform various actions on processes: - Archive processes to remove them from active views - Organize processes into folders - Add processes to favorites for quick access - Export process data to CSV - View aggregated form responses across all tasks These management features help maintain a clean, organized workspace while preserving important historical data. :::tip[Viewing all form data in one place] **Need to see all form responses without clicking through tasks?** Open any process from the Tracker view and change the view to the **Preview** option. This shows all form field responses collected throughout the process in a summary format. Perfect for project managers who need quick overviews without navigating task-by-task. ::: :::note[Table view export requirements] **Blueprint selection is mandatory** for exporting from table view. You must select a specific template/blueprint before the export option becomes available. **Why this requirement exists**: - Different templates have different field structures and data types - CSV exports need consistent column formatting across all rows - Cross-template data would create incompatible column headers **Workarounds for multi-template exports**: 1. Export each template separately, then combine in spreadsheet software 2. Use dashboard views for cross-template summaries 3. Consider using [Tallyfy Analytics](/products/pro/integrations/analytics/) for full reporting across multiple templates **Best practice**: Filter to your desired template first, apply any additional filters, then export. Use descriptive file names to track which template each export contains. ::: ### Understanding custom view display logic **Why completed processes still appear**: Custom views show processes where you're **involved**, not just where you have **outstanding tasks**. You're considered "involved" in a process if: - You were assigned to any task (even if completed) - You were mentioned or tagged in comments - You participated in approval or review steps - You're listed as the process owner **Managing your view for clarity**: - **"My Tasks" view**: Shows only processes with your pending tasks - **Custom views**: Shows all processes where you're involved (including completed work) - **Use status filters**: Filter by "Active" to hide completed processes - **Archive completed work**: Remove finished processes from active views This design helps you track overall involvement and maintain historical visibility while allowing filtering for current work only. ### Current sorting limitations **Available sorting options**: - Process name (alphabetical) - Status (active, complete, archived) - Created date - Last modified date - Due date (based on template deadlines) **Not yet available - Form field sorting**: You cannot currently sort by custom form field data such as: - Date fields from kick-off forms (e.g., "move-in date", "project deadline") - Dropdown selections (e.g., priority levels, categories) - Number fields (e.g., contract value, quantity) - Custom text fields **Workarounds for custom sorting needs**: 1. **Include sort data in process names** - Add dates or priorities to the process name (e.g., "2025-08-12 - Client Onboarding - High Priority") 2. **Export and sort externally** - Export to CSV for custom sorting in spreadsheet software 3. **Use filters instead** - Filter by specific form field values rather than sorting 4. **Create multiple presets** - Save different filtered views for different sorting needs Form field sorting is planned for future development. Contact support to vote for this feature priority. :::note[Future enhancements] We're exploring additional view options including Calendar, Gantt charts, Timeline views, and enhanced sorting by form fields. Share your preferences with our support team - your feedback directly influences our development roadmap. ::: - **[Tasks view](https://tallyfy.com/products/pro/tracking-and-tasks/tasks-view/)**: The Tasks View in Tallyfy serves as a centralized master to-do list that consolidates all individual tasks from every process and project in your workspace along with standalone tasks while offering powerful filtering options and the ability to create new one-off tasks directly from the interface. ## The Tasks view The **Tasks View** in Tallyfy (click it in the left sidebar) shows all your individual tasks in one place - across every process and project in your workspace. Think of it as your master to-do list. It pulls together tasks from running processes plus any standalone one-off tasks you've created. No more hunting through emails or spreadsheets to figure out what you need to do today. ### How do I use filters in the Tasks view? Filters help you find what you need. Fast. The **Filters** button opens up powerful sorting options that let you slice and dice your task list however you want. Here's what you can filter by: * **Assignee**: See tasks assigned to yourself, someone else, a guest (by email), or unassigned tasks waiting for an owner * **Status**: View tasks that are 'To Do' (that's the default) or switch to 'Completed' to see what's done * **Task State**: Check which tasks are 'Overdue' (yikes), 'Due Soon' (better get moving), or 'On Time' (you're good) * Tags, Templates, Folders, and more... See [Customize the Task View](/products/pro/tracking-and-tasks/tasks-view/how-can-i-customize-task-views-in-tallyfy/) for details on using filters. :::tip[Can't Find a Task? Check Your Filters!] Missing a task you know exists? Nine times out of ten, it's the filters. Maybe you're looking for a task assigned to a guest (filter by their email) or something you already finished (switch Status to 'Completed'). Double-check those filter settings - they're probably hiding what you're looking for. ::: :::note[Tasks mixed from multiple processes?] **Finding the Tasks view confusing with many processes running?** This is normal - the Tasks view shows ALL tasks from ALL processes mixed together. For a process-grouped view: 1. Use the **Tracker view** instead - it organizes by process 2. Click into any specific process to see only its tasks 3. Or filter the Tasks view by Template/Process name to focus on one workflow The Tasks view is designed as a personal to-do list showing everything assigned to you, regardless of which process it's from. Use the Tracker view when you need process-level organization. ::: ### How can I create tasks from this view? Need to add a quick task? Hit the **+ Create** button. You can [create new one-off tasks](/products/pro/tracking-and-tasks/tasks/how-to-create-a-one-off-task-in-tallyfy/) right from this view - perfect for those random to-dos that pop up but don't need a full process. Think "Call vendor about pricing" or "Review quarterly report" - simple stuff that just needs to get done. ### Processes - **[Export process to CSV](https://tallyfy.com/products/pro/tracking-and-tasks/processes/how-can-i-export-tallyfy-processes-to-csv/)**: Tallyfy lets you export any running process to CSV format with one click giving you complete data including tasks form answers comments and timestamps for analysis reporting audits or backup in any spreadsheet program. ## Export processes to CSV format You can export any running process to CSV format directly from Tallyfy - just open the process, click **Settings**, and hit **Export CSV** at the bottom. The entire process downloads as a spreadsheet file in seconds. Need to analyze your [processes](/products/pro/tracking-and-tasks/processes/) in Excel or create custom reports? That's exactly why we built CSV export. You get everything - tasks, form answers, comments, timestamps - in a format that works with any spreadsheet program. Perfect for monthly reporting, compliance audits, or just backing up your data. ### What do I need to export a process? - Access to view the running process you want to export. ### How do I export a process to CSV? ### What's included in the CSV file? The CSV file gives you a complete snapshot of your process - think of it as an X-ray that shows everything happening inside. Each row tells a different part of the story: one might show a completed task, another captures a form answer, and another records a comment someone left. Here's what you'll find: * **Process Info**: The basics like process name, ID, which template it came from, when it started and ended, plus who owns it * **Task Info**: Every task's name, current status (complete, active, waiting), due dates, completion times, and who's responsible for what * **Milestone Data**: If you're using milestones to track major checkpoints, you'll see their IDs, names, and where they fit in the process flow * **Form Field Data**: All those questions you asked? The answers are here - field names, user responses, even file upload details * **Hidden Items**: Here's something interesting - even hidden [tasks](/products/pro/tracking-and-tasks/tasks/) show up in exports (handy for audits) * **Metadata**: The behind-the-scenes stuff - system details and tracking info that help piece together the complete picture Want the full breakdown? The [CSV File Structure article](/products/pro/integrations/analytics/how-is-the-csv-file-structured-in-tallyfy/) covers all 48 columns in detail. :::note[Timestamp handling in exports] All timestamps in CSV exports are stored in ISO 8601 format without timezone information. While this ensures consistent data storage, remember that in Tallyfy's interface these timestamps are displayed converted to your personal timezone setting for accurate local time display. ::: ![CSV export spreadsheet with process data](https://screenshots.tallyfy.com/tallyfy/pro/analytics-csv-export-spreadsheet.png) ### Bulk export for multiple processes Need to export many processes at once? The manual export works great for individual processes, but if you need to export all processes from your organization - or filter by status or template - use the bulk export script. **Python Bulk Export Script**: Our open-source script in the [api-support repository](https://github.com/tallyfy/api-support/tree/master/Bulk%20Exports) lets you: - Export all processes to a single CSV file - Filter by status (active, complete, or all) - Filter by template ID - Handle pagination automatically for large organizations ```bash # Export all processes python3 export_processes_csv.py # Export only active processes python3 export_processes_csv.py --status active # Export processes from specific template python3 export_processes_csv.py --template YOUR_TEMPLATE_ID ``` The script produces the same 49-column format as manual exports - one row per task in each process. See the [API code samples](/products/pro/integrations/open-api/code-samples/) for more programmatic options. ### Alternative export methods for form data **Need real-time form data export?** Besides manual CSV export, you can: - **Use webhooks** to automatically send form data to external systems when tasks complete - **Connect via API** to pull form field data programmatically - **Set up middleware** (Zapier, Make) to stream form responses directly to spreadsheets See [webhook setup](/products/pro/integrations/webhooks/how-to-set-up-webhooks-in-tallyfy/) for automated data export. ### How can I use the exported data? Once you've got that CSV file, the possibilities open up. Here's what most teams do with their exports: 1. **Analysis**: Pop it open in Excel or Google Sheets and dig into the numbers - how long did tasks actually take? Who's your fastest approver? Which steps always get stuck? 2. **Reporting**: Build those charts your boss loves. Show process completion trends, average cycle times, or bottleneck patterns with real data 3. **Backup**: Smart move - keep offline copies of important processes. You never know when you'll need that audit trail from six months ago 4. **Integration**: Feed the data into Power BI, Tableau, or whatever analytics tool your team uses. CSV plays nice with everything 5. **Auditing**: Compliance teams love this feature. Every action, timestamp, and decision is right there in black and white :::note[Large Files] Got a process with hundreds of tasks or tons of form data? Your CSV might get pretty hefty. Excel and Google Sheets handle most files just fine, but if you're dealing with something massive (we're talking thousands of rows), you might need something beefier like a database tool. ::: - **[Share a process](https://tallyfy.com/products/pro/tracking-and-tasks/processes/make-a-process-public/)**: Tallyfy administrators can generate public links that allow external stakeholders to view running processes in real-time without login credentials while maintaining read-only access and security controls over what information is shared. ## Make a process visible to outsiders :::note[Why is this an admin-only feature?] For security reasons, only Tallyfy users with the **Administrator** [role](/products/pro/documenting/members/) can make a running process publicly accessible. This restriction protects sensitive organizational information and ensures controlled access to critical workflows. ::: Need to share process updates with a client who doesn't have Tallyfy access? Simple. Generate a public link - anyone with it can view your process in real-time without making changes. Perfect for keeping external stakeholders in the loop. You might use this when you're managing a project for a client and they want visibility into progress. Or maybe you're working with a partner company and need to share workflow status. Tallyfy's secure public links give you that transparency without the security headaches. Your stakeholders see exactly what's happening (comments, tasks, progress - whatever you choose to share), but they can't modify anything. Here's the thing: it's all read-only. Complete visibility, zero risk. ### How do I get the public link for a process? :::caution[What are the security implications of public links?] Exercise extreme caution when using this feature. **Anyone** who obtains this link can view the process details you've chosen to make visible. This might include sensitive task status information, internal comments, form field answers, and assignee names. If you only need specific external people to complete *certain tasks*, it's significantly more secure to add them as [guests to those specific steps](/products/pro/documenting/guests/how-can-i-assign-tasks-to-guest-users-in-tallyfy/) instead of making the entire process publicly accessible. Guest access provides superior control and enhanced security. ::: ### How does the public setting affect guest visibility? Here's where it gets interesting. Making a process public doesn't just create a shareable link - it changes what your [guests](/products/pro/documenting/guests/) can see too. When you flip that **Public to the world** switch to **Yes**, your guests suddenly get a much wider view in the [Tracker view](/products/pro/tracking-and-tasks/tracker-view/): - **Private process** (default): Guests only see their own tasks. That's it. - **Public process**: Guests can see **ALL tasks** in the entire process - even ones they're not assigned to :::warning[Critical security consideration] When you make a process public, ALL guests assigned to ANY task in that process can see EVERY task in the workflow, including: - Tasks assigned to other guests/vendors - Internal company tasks - All form field data entered - All comments and discussions - File attachments Think about that for a second. If you've got multiple external vendors working on different parts of a project, making it public means they'll all see each other's tasks AND your internal work. Sometimes that's exactly what you want (transparency breeds accountability). Sometimes it's definitely not. ::: The [Tasks view](/products/pro/tracking-and-tasks/tasks-view/)? Different story. Guests still only see their assigned tasks there, public or not. :::warning[Important consideration for guest privacy] If your process contains tasks assigned to different external guests who shouldn't see each other's work, keep the process private. Public processes are best suited for situations where full transparency is desired among all participants. ::: Got your public link? Share it with anyone who needs to see what's happening. Your client gets real-time updates, you maintain control - everyone wins. - **[Commenting processes](https://tallyfy.com/products/pro/tracking-and-tasks/processes/how-can-i-manage-comments-in-tallyfy/)**: Process comments in Tallyfy enable team discussions about the overall workflow with features for adding editing and deleting comments using @mentions and maintaining a permanent history that stays separate from individual task-level communications. ## Add, edit, and delete comments on processes Tallyfy process comments are for discussions about the *overall* [process](/products/pro/tracking-and-tasks/processes/), rather than specific [tasks](/products/pro/tracking-and-tasks/tasks/) within it. Anyone who can view the process can usually see and add process comments. This communication approach maintains clear separation between process-level and task-level discussions. ### How do I add comments to a process? ### How do I mention people in comments (@mentions)? To make sure a specific person sees your comment, you can @mention them: ### How can I edit my own process comments? If you made a mistake in a comment you posted: ### How do I delete my process comments? If you need to remove a comment you posted: ### What is the difference between process and task comments? * **Process comments**: For general discussion about the whole workflow. Visible at the bottom of the main process view. * **[Task](/products/pro/tracking-and-tasks/tasks/) comments**: For questions or updates about a *specific task*. Visible only when you open that task. Use process comments for overall updates, and task comments for task-specific details. ### How does comment history work? All process comments are saved with the process, creating a history of the discussion. This permanent record can be useful for understanding past decisions or getting new team members up to speed. ### Do template comments appear in launched processes? No. Comments made on a template during the editing phase stay with the template - they do not inherit or carry over when you launch a process from that template. Template comments are for discussions about template design and structure, while process comments are for discussions about the actual running work. This separation keeps template editing discussions private and prevents confusion in active processes. - **[Process lifecycle management](https://tallyfy.com/products/pro/tracking-and-tasks/processes/process-lifecycle-management/)**: Tallyfy process lifecycle management involves five phases - create templates with logical organization and detailed instructions, launch customized instances with proper context, execute tasks sequentially, monitor progress through tracker views to catch issues early, and complete processes while analyzing data for continuous improvement. ## Process lifecycle in Tallyfy Processes in Tallyfy follow five phases: create, launch, execute, monitor, and complete. ### Process lifecycle phases A process moves through Tallyfy in these phases: 1. **Creation** - You build the template (like designing the train route) 2. **Launch** - You start a new instance (the train leaves the station) 3. **Execution** - Tasks get completed one by one (passengers board at each stop) 4. **Monitoring** - You track progress in real-time (watching the train's location) 5. **Completion** - Everything wraps up and you analyze results (reaching the destination) ### Creating templates Key elements: - **Organize logically**: Put steps in the order people actually work - not how the org chart says they should - **Add detailed instructions**: Write them like you're explaining to someone on their first day (because someday, you will be) - **Set proper assignments**: Match tasks to job titles, not just people. New hire? They'll automatically get the right work - **Include form fields**: Capture the data you need when you need it - no chasing people for missing info - **Configure automations**: Let Tallyfy handle the boring stuff. Auto-assign tasks, set deadlines, send reminders ### Launching processes Steps: - **Customize for the specific instance**: Every client onboarding is different - adjust deadlines and assignments to match reality - **Provide context**: Add launch notes to explain the specific situation - **Send notifications**: Alert assignees about their new tasks - **Verify settings**: Double-check assignments and deadlines before launch ### Monitoring active processes The tracker view shows all active processes: - **Use the Tracker view**: See which processes are humming along and which need attention. Green means go, red means investigate - **Check process health**: That task stuck for 3 days? Time to nudge someone or reassign it - **Review comments**: The real story often lives in task comments - questions, blockers, "waiting on vendor" updates - **Monitor form data**: Spot incomplete submissions before they mess up your reporting - **Handle exceptions**: When the unexpected happens (and it will), you'll see it here first ### Process tracking best practices Effective tracking habits: - **Regular check-ins**: Monday morning dashboard review, Thursday afternoon deep dive - pick a rhythm and stick to it - **Dashboard utilization**: View patterns across all processes - multiple items stuck at the same step indicates a bottleneck - **Notification management**: Configure alerts for critical events only - **Deadline tracking**: Check for tasks turning yellow (due soon) before they go red (overdue) - **Issue resolution**: Answer questions in comments quickly to prevent blockers ### Process completion Checklist: - **Verify all tasks are complete**: Check for any forgotten approvals or signatures - **Review captured data**: Confirm all required fields have values - **Export data if needed**: Extract data for reports or audits - **Archive for reference**: Store completed processes for future reference - **Learn and improve**: Identify consistently late or skipped steps to adjust the template ### Common challenges and solutions | Challenge | Solution | |-----------|----------| | Bottlenecks | Check who's overloaded - if Sarah has 15 tasks and Tom has 2, time to rebalance | | Missed deadlines | Build in buffer time. If it really takes 3 days, don't set a 2-day deadline | | Incomplete data | Make critical fields required. Can't proceed without a PO number? Make it mandatory | | Process abandonment | Set up a 48-hour reminder rule - gentle nudge before things go stale | | Unclear responsibility | Name names. "Marketing team" is vague. "Content Manager" is clear | | Missed steps | Every task appears in someone's queue - Tallyfy won't let steps vanish | | Downstream problems | Daily tracker check catches issues while they're still small | ### Analyzing processes After 10-20 runs: - **Review completion times**: Check actual vs. expected durations. For accurate effort measurement, see [how to track time spent on tasks](/products/pro/tutorials/how-to/track-time-in-tasks/) - **Identify patterns**: When three different processes stall at legal review, you've found your bottleneck - **Collect feedback**: Ask team members for specific pain points - **Implement changes**: Adjust one element at a time and test - **Monitor improvements**: Check metrics after 5-10 runs to verify changes worked - **[Edit processes](https://tallyfy.com/products/pro/tracking-and-tasks/processes/edit-processes/)**: Running processes can be modified after launch by adding tasks changing assignees or due dates renaming the process instance and archiving completed runs while preserving the original template structure. ## Edit running processes Yes, you can edit a [process](/products/pro/tracking-and-tasks/processes/) after it's launched - just make changes to that specific run without touching your original template. Need to add an unexpected task? Change who's assigned? Update a deadline? Done. Here's what you can edit in a running process: * Add extra one-off [tasks](/products/pro/tracking-and-tasks/tasks/) that weren't in the template (perfect for those "oh, we need to do this too" moments) * Change task details - reassign them, adjust due dates, whatever you need * Rename the process instance to something more specific * Archive or delete the process when you're finished with it Your original template stays exactly as it was. Think of it like editing a copy of a document - the master version remains untouched while you customize the working copy for this particular situation. The articles below show you exactly how to make these changes.   Learn more about editing [processes](/products/pro/tracking-and-tasks/processes/) with these articles: ### Edit processes - **[Add tasks to active processes](https://tallyfy.com/products/pro/tracking-and-tasks/processes/edit-processes/how-can-i-add-tasks-to-active-processes-on-tallyfy/)**: Tallyfy allows you to add new tasks to running processes even after they've launched providing flexibility to adapt workflows on-the-fly either by adding tasks directly within the process view or by linking existing one-off tasks without affecting the original template. ## Add tasks to active processes You can add new [tasks](/products/pro/tracking-and-tasks/tasks/) to running [processes](/products/pro/tracking-and-tasks/processes/) in Tallyfy - even after they've already launched. This gives you the flexibility to adapt workflows on the fly when requirements change. Need an extra approval step? Forgot something important? No problem. You can add tasks without restarting the process or changing the original template. ### What are my options for adding tasks on the fly? Tallyfy gives you two ways to add tasks to a running process. Pick whichever works best for your situation: ### Method 1: Add tasks directly within the process view ### Method 2: Link an existing one-off task ### What should I know about added tasks? * You can add as many tasks as you need - there's no limit. * Added tasks usually have a visual indicator (like "Linked to") so you know they weren't in the original template. * Here's the important part: adding tasks to a running process does **not** change your original template. The template stays exactly as it was. - **[Auto-name a process](https://tallyfy.com/products/pro/tracking-and-tasks/processes/edit-processes/how-can-i-auto-name-a-process-in-tallyfy/)**: Auto-naming in Tallyfy automatically generates consistent process names using data from kick-off form fields to eliminate manual naming chaos and create organized searchable workflows. ## Why should I auto-name processes? You're probably tired of hunting through processes named "Untitled" or "Test 123" - we've all been there. Manually naming each Tallyfy [process](/products/pro/tracking-and-tasks/processes/) creates a mess. Different team members use different naming styles, and suddenly you can't find that critical client onboarding from last week. One person names it "Coca Cola onboarding", another calls it "Pepsi project". Sound familiar? Auto-naming fixes this chaos. It creates a consistent naming pattern for every process launched from a [template](/products/pro/documenting/templates/). Here's the magic: the feature pulls values directly from your kick-off form fields - think of it as automatic name generation that actually makes sense. Your team enters data once, and Tallyfy instantly creates dynamic project names that everyone understands. Watch what happens with those messy examples above. Auto-naming transforms them into "Onboarding - Coca Cola - Memphis" and "Onboarding - Pepsi - New York". Clean. Searchable. Professional. You'll know exactly what each process covers at a glance, and your tracking stays organized without any extra work. ## Can I rename processes using field values? Absolutely - Tallyfy's auto-naming pulls values straight from your kick-off form fields. No more typing "Client Onboarding - ABC Corp - January 2025" manually every single time. Set up your naming pattern once, and you're done. Here's what happens with field-based naming: - Your team fills out the kick-off form (client name, location, date - whatever you need) - Tallyfy grabs those values and builds the process name automatically - Every process follows your exact naming structure - no exceptions - The name appears instantly when someone launches the process Here's a comparison showing how auto-naming improves clarity of process names: | Bad Naming (Inconsistent/Manual) | Good Naming (Consistent/Auto-Named) | | -------------------------------- | ------------------------------------- | | Onboarding Client | Onboarding - Coca Cola - Memphis | | Acme Corp | Onboarding - Pepsi - New York | | New Hire | New Hire - Jane Smith - Marketing | | John Doe Start | New Hire - Bob Johnson - Engineering | | Ticket #123 | Support - TKT-456 - Beta Inc - Login | | Urgent Fix | Support - TKT-457 - Gamma LLC - Billing | ## How do I set up automatic process naming? Setting up auto-naming takes about 2 minutes. You'll configure it once in your [template](/products/pro/documenting/templates/), and every [process](/products/pro/tracking-and-tasks/processes/) launched from that template gets the perfect name automatically. That's it! When someone launches a process from this template, Tallyfy automatically generates the name using your pattern and the kick-off field data. No manual typing, no inconsistencies - just perfectly named processes every time. :::note[Only Required Kick-off Fields Work] You can only use variables from **required** [kick-off form fields](/products/pro/launching/triggers/kick-off-forms/) in your naming pattern. Why? Because required fields always have values - so your process names never end up with awkward blanks or missing information. ::: :::note[Name Length Limit] Process names max out at 550 characters. That's plenty for most patterns, but if you're adding lots of variables, keep it reasonable. ::: - **[Delete a process](https://tallyfy.com/products/pro/tracking-and-tasks/processes/edit-processes/how-can-i-delete-a-process-in-tallyfy/)**: Tallyfy requires users to first archive active or completed processes before permanently deleting them through a two-step safety mechanism that prevents accidental data loss with no recovery option available. ## Permanently delete an archived process You can't delete active or completed [processes](/products/pro/tracking-and-tasks/processes/) in Tallyfy - you need to **archive them first**. Only then does the delete option appear. Here's the thing: once you delete an archived process, it's gone forever. **There's no undo button.** Tallyfy makes you take these two steps on purpose - it stops you from accidentally wiping out important data. Not sure how to archive a process? Check out [How to archive and unarchive processes](/products/pro/tracking-and-tasks/tracker-view/organize-processes/how-to-archive-and-unarchive-processes-in-tallyfy/) for step-by-step instructions. - **[Edit tasks and process properties](https://tallyfy.com/products/pro/tracking-and-tasks/processes/edit-processes/how-can-i-edit-tasks-and-processes-in-tallyfy/)**: You can modify various properties of running processes in Tallyfy including the process name owner deadline tags folder location and notes by accessing the Settings button from the Tracker view which opens a panel where these changes can be made without restarting the workflow. ## Edit running process properties You can change process settings even after they're running - just open the process and click the **Settings** button. Perfect for when plans change mid-workflow. No need to start over. ### How do I access process settings? ### What properties can I edit in a running process? Once you're in the settings panel (it opens on the Summary tab), here's what you can change: * **Process Name**: Click the name at the top and type a new one. Simple. * **Process Owner**: Need someone else to take over? Click the edit icon next to the owner's name. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-change-process-owner.png) * **Process Deadline**: Adjust the overall due date when timelines shift. * **Tags**: Add tags to categorize and find this process later. Really helpful when you're juggling multiple workflows. * **Process Folder**: Move it to a different folder in your Tracker or Tasks view - keeps everything organized. * **Process Notes**: Add notes about this specific run. Great for context that doesn't fit anywhere else. You'll also see (but can't edit) a few things: * The original [template](/products/pro/documenting/templates/) description * Answers from the [kick-off form](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) ### What other process actions are available? Look at the bottom of the settings panel - you'll find an **Export CSV** button to download all your process data. :::note[Where can I archive a process?] The archive option is available in the **Tracker view** by clicking the three-dot menu (...) on a process card. See [how to archive and unarchive processes](/products/pro/tracking-and-tasks/tracker-view/organize-processes/how-to-archive-and-unarchive-processes-in-tallyfy/) for detailed instructions. ::: :::note[What permissions do I need to edit processes?] Your editing options depend on your role - Administrators can edit everything, while Standard members might have some restrictions. Process owners typically get more control over their own processes. ::: ### When should I edit process properties? Here's when you'll typically need to make changes: * Someone else needs to take ownership (vacation, reassignment, etc.) * Plans changed mid-workflow and you need to adjust details * You want to add notes about what's happening in this specific run * Your process list is getting messy - time to reorganize with tags or folders * That deadline isn't looking so realistic anymore ### What are best practices for editing processes? A few tips to keep things running smoothly: * Tell your team when you make big changes - especially new owners or deadlines. Nobody likes surprises. * Keep your tags consistent. If you use "Q4-Planning" in one place, don't use "Q4 Planning" somewhere else. * Drop a note in the Notes section when you make major changes. Future you will thank present you. - **[Add process notes](https://tallyfy.com/products/pro/tracking-and-tasks/processes/edit-processes/how-to-add-process-notes/)**: Process notes in Tallyfy provide a centralized location for storing important information files and links that remain visible across all tasks in a specific process run ensuring team members have consistent access to critical context and resources throughout the workflow. ## How do process notes work in Tallyfy? Process notes in Tallyfy give you a single place to store important information, files, and links for a specific [process](/products/pro/tracking-and-tasks/processes/) run. Everyone involved can see them - they show up in the process overview and on each individual [task](/products/pro/tracking-and-tasks/tasks/). Simple. This way, nobody misses critical information no matter which task they're working on. ### Why should I use process notes in Tallyfy? - **Provide essential context**: Add background info that helps your team understand what's special about this process run - **Maintain information visibility**: Notes show up on every task - participants can't miss them - **Centralize critical details**: Keep all process-specific information in one spot (no more hunting through emails) - **Share resources efficiently**: Attach documents and links once, and they're available throughout the workflow ### How do I add or edit process notes in Tallyfy? :::note[Who can add process notes?] Process notes can typically be added or edited by the process owner, administrators, and in some cases standard members with appropriate permissions. ::: ### Where do process notes appear in Tallyfy? You'll find process notes in two key places: 1. **In the process settings**: Look under Settings > Summary tab for centralized management 2. **On each individual task**: They show up in the "Process Details" section of every task - this means everyone sees the same information, no matter which task they're on ### What should I include in effective process notes? Here's what makes process notes actually useful: - **Essential context**: Why are we running this process? Document any special circumstances that matter - **Resource links**: Drop in URLs to documents, systems, or tools people will need - **Critical files**: Attach files that everyone needs access to throughout the workflow - **Key contacts**: List stakeholders who aren't in the process but might need to be reached - **Special instructions**: Flag any exceptions or unusual requirements for this specific run - **Real-time updates**: Add new information as it comes up during execution ### What are best practices for writing effective process notes? - **Keep it brief**: These notes appear on every single task - don't overwhelm people with walls of text - **Format for clarity**: Use bold text and bullet points to make information easy to scan - **Update as you go**: Things change? Add new info as the process moves forward - **Don't repeat yourself**: If it's already in the task description, skip it in the notes - **Write for everyone**: Remember - all participants can see these notes, so keep them professional - **[Rename a process](https://tallyfy.com/products/pro/tracking-and-tasks/processes/edit-processes/how-can-i-rename-a-process-in-tallyfy/)**: Running process names can be changed by clicking directly on the process name at the top of the process view and typing a new name then pressing Enter to save. ## Change the name of a running process Click directly on the process name at the top of any running [process](/products/pro/tracking-and-tasks/processes/) and type a new name - that's it. You can rename processes anytime after they're launched to keep things organized. Here's exactly where to click: ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-change-process-name.png) ### Tasks - **[Choosing the right field type](https://tallyfy.com/products/pro/tracking-and-tasks/tasks/choosing-the-right-form-field-type/)**: Selecting the right form field type in Tallyfy affects user experience and data quality with radio buttons working best for short lists of 2-5 options while dropdowns suit longer lists and checklists require at least 2 items for multi-item verification rather than simple confirmations. ## Selecting the best form field for your workflow Choosing the right field type isn't just about what data you want to collect - it's about what that data represents and how users will interact with it. The wrong choice can confuse users or create meaningless data that doesn't help your workflow. ### Quick decision guide | What you need | Best field type | Why | |---------------|-----------------|-----| | User picks ONE from a short list (2-5 options) | **Radio buttons** | All options visible, fastest selection | | User picks ONE from a longer list (6+ options) | **Dropdown** | Saves space, searchable | | User confirms multiple items were done | **Checklist** | Multi-select with validation options | | Simple yes/no confirmation | **Radio buttons** | Two clear options, no ambiguity | | User enters a specific date | **Date** | Calendar picker prevents format errors | | User needs to explain something | **Long text** | Room for detailed responses | | User enters brief data (name, number) | **Short text** | Single line with optional validation | | User must upload evidence | **File upload** | Supports multiple files up to 100MB each | | User selects who should do something | **Assignee picker** | Integrates with Tallyfy members | | User enters structured data rows | **Table** | Defined columns, unlimited rows | ### When NOT to use a checklist Checklists require a minimum of 2 items because a single-item checklist isn't a choice - it's just confirmation. If you have only one thing to verify, use a different approach. **Single-item scenarios - better alternatives:** | Instead of this | Use this | Example | |-----------------|----------|---------| | Checklist with 1 item | **Yes/No radio buttons** | "Has payment been received?" with Yes/No options | | Single-option dropdown | **Yes/No radio buttons** | "Approved?" with Yes/No options | | Checkbox for confirmation | **Radio buttons + conditional fields** | See payment example below | **The payment confirmation example:** Bad approach: A dropdown with only "Yes" as an option for "Payment received?" Good approach: 1. **Radio buttons**: "Has payment been received?" → Yes / No 2. **Conditional date field** (shown if Yes): "Date payment appeared in bank account" 3. **Optional file upload**: "Upload proof of payment (bank statement)" This provides actual proof of work - not just a meaningless single-item selection. ### When to use checklists Checklists work best for multi-item verification where: - Users need to confirm they completed several related items - The order of completion doesn't matter - Some or all items may apply depending on the situation **Good checklist examples:** - **Quality check**: "Verified formatting", "Checked for errors", "Confirmed accuracy", "Reviewed by second person" - **Equipment handover**: "Laptop returned", "Badge collected", "Keys returned", "Parking pass collected" - **Approval criteria**: "Budget approved", "Legal reviewed", "Manager signed off", "IT security cleared" **Checklist validation options:** You can require: - At least one item checked - All items checked - No validation (purely informational) ### When to use radio buttons vs dropdown Both let users pick ONE option. The difference is how options display. **Use radio buttons when:** - You have 2-5 options (all fit on screen) - Users need to see all choices at once - Decisions are mutually exclusive and clear **Use dropdown when:** - You have 6+ options - Screen space is limited - Options are self-explanatory (users don't need to compare) **Pro tip**: For yes/no questions, always use radio buttons - never a dropdown with two options. Radio buttons make the binary choice immediately clear. ### Field type and automation rules Your field choice affects what [automation rules](/products/pro/documenting/templates/automations/) you can create: | Field type | Can trigger rules based on | Example rule | |------------|---------------------------|--------------| | Radio buttons | Exact selection | If "Priority" = "High" then assign to Manager | | Dropdown | Exact selection | If "Department" = "Finance" then show finance steps | | Checklist | Contains specific item | If "Requirements" contains "Legal Review" then show legal step | | Short text | Contains, equals, is empty | If "Country" contains "USA" then show US compliance step | | Date | Before/after dates | If "Start Date" is before today then show warning | Choose fields that support the automation rules your workflow needs. ### Common mistakes to avoid 1. **Using dropdown for binary choices** - Use radio buttons instead; dropdowns add unnecessary clicks for yes/no decisions 2. **Single-item checklists** - These don't work and aren't useful; use radio buttons or conditional fields 3. **Long text for structured data** - If you need specific pieces of information, use separate short text fields or a table 4. **File upload for small confirmations** - Don't require file uploads when a simple confirmation would suffice; it creates friction 5. **Missing validation** - If a field must be filled, mark it required; if text must be an email, enable email validation - **[How to duplicate or clone tasks](https://tallyfy.com/products/pro/tracking-and-tasks/tasks/duplicate-clone-tasks/)**: Duplicate or clone tasks in Tallyfy to quickly create similar tasks with the same settings and form fields while saving time on repetitive task creation in your workflows. ## How to duplicate tasks Want to create similar tasks without all the repetitive setup? Just clone them. Tallyfy lets you duplicate existing tasks - complete with all their settings, form fields, and configurations (except comments). It's like having a fresh copy to work with. This feature really shines when you're creating multiple approval steps, collecting the same data at different stages, or basically any time tasks share most of their configuration. Think of it as your workflow copy machine. ## Prerequisites - Administrator or Standard user role - A [template](/products/pro/documenting/templates/) in edit mode - An existing task to duplicate ## When to use task duplication You'll find yourself reaching for the clone button in these situations: - **Multiple approvals**: Need Finance, Legal, and Operations to all approve something? Clone that first approval task instead of rebuilding it three times - **Repeated data collection**: Collecting inventory data from 5 warehouses? Create one perfect form, then clone it for each location - **Parallel workflows**: When different team members need the same task with identical instructions - why type it all again? - **Template variations**: Building similar processes becomes way faster when you start with a working template and tweak from there ## How to duplicate a task in templates ## What gets copied when cloning ### Copied elements Here's what comes along for the ride: - Task name (you'll see "Copy of" in front - we'll talk about renaming in a bit) - Task type (whether it's a regular task, approval, email task, etc.) - All form fields and their settings - Task description and instructions - Deadline settings - Assignment rules - Any automation rules that affect the task - Advanced settings ### Not copied These stay behind with the original: - Task comments - Task completion status - Historical data - Task-specific IDs or references Makes sense, right? You get a clean slate with all the configuration intact. ## Best practices for task duplication 1. **Rename immediately**: First thing - get rid of that "Copy of Task Name" label. Nobody wants a template full of "Copy of Copy of Approval Task" 2. **Update assignments**: The clone inherits all assignment rules from the original. Double-check who's getting assigned what 3. **Verify form fields**: Make sure those copied form fields still make sense for your new task. Field names matter for data collection 4. **Test automations**: Got automation rules on the original? Test them. Sometimes cloned tasks need their own automation tweaks 5. **Consider task order**: Clones appear right after the original. Drag them where they actually belong in your workflow ## Common use case examples ### Example 1: Multiple department approvals Let's say you need Finance, Legal, and Operations to all approve a new vendor. Same approval form, different people. Here's the play: 1. Build out that Finance approval task with all the fields you need 2. Clone it twice - boom, instant copies 3. Rename them to "Legal Approval" and "Operations Approval" (no more "Copy of" confusion) 4. Switch the assignees to each department head 5. Tweak any department-specific fields - maybe Legal needs an extra compliance checkbox Simple. ### Example 2: Multi-location data collection Picture this: You're collecting inventory data from 5 warehouses. Same exact form for each location. Don't build it five times! 1. Create your perfect inventory form for Location A 2. Hit clone 4 times 3. Rename each clone for locations B through E 4. Update the location details and who's responsible at each site That's 20 minutes of work instead of 2 hours. ### Example 3: Parallel task assignments Three quality inspectors need to check the same things? Clone to the rescue: 1. Set up the quality check task with all your criteria 2. Clone it twice 3. Just change the assignees - everything else stays identical Each inspector gets their own task, but you only built it once. ## Tips for efficient cloning - **Build once, clone many**: Get that first task perfect before you start cloning. Trust me - fixing the same typo in 10 cloned tasks is nobody's idea of fun - **Use variables**: Here's a pro move - set up [variables](/products/pro/documenting/templates/variables/) in your original task. Then all your clones can pull from the same shared data. Change it once, updates everywhere - **Clone groups**: Got a whole sequence of related tasks? You can clone them as a group and keep all their relationships intact. Way faster than rebuilding complex workflows - **[Complete or reopen tasks](https://tallyfy.com/products/pro/tracking-and-tasks/tasks/how-can-i-complete-or-reopen-tasks-in-tallyfy/)**: Tallyfy tasks can be completed by clicking the checkmark icon in list views or using the Complete button within the task and can be reopened by clicking the Re-Open button with options to restrict completion to only assigned members through advanced settings. ## Complete or reopen tasks ### How do I complete tasks in Tallyfy? You can complete [tasks](/products/pro/tracking-and-tasks/tasks/) in two ways - either click the checkmark icon in any list view, or open the task and hit the **Complete** button. Here's how: That's it. Task marked complete. ### How can I reopen completed tasks? Need to undo a completed task? Just open it and click **Re-Open**. The task becomes active again. ### How can I control who completes or reopens tasks? If you need to restrict task completion and reopening to only assigned members, use the **"Only assigned members can complete or edit this task"** setting in the [Advanced tab](/products/pro/tracking-and-tasks/tasks/how-can-i-utilize-tallyfys-advanced-tab-features/): Here's what happens when you turn this on: * Only people assigned to the task can complete it * Only assigned members can reopen the task after it's completed * Non-assignees won't see the **Complete** or **Re-Open** buttons * Nobody can accidentally (or intentionally) complete someone else's work :::note[Admin override] Administrators can always complete, reopen, or edit any task, regardless of this setting. ::: ### How do I complete tasks that have subtasks (checklists)? Got a task with a checklist? These work a bit differently. The checklist [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) acts like mini subtasks you need to check off. You can't complete the main task until all its required fields are filled out - including any checklist requirements. The **Complete** button stays grayed out until everything's done. :::tip[Learn more about checklists as subtasks] See [Create and use subtasks (Checklist field)](/products/pro/tracking-and-tasks/tasks/how-to-create-and-use-subtasks/) for how to set these up. ::: - **[Manage comments](https://tallyfy.com/products/pro/tracking-and-tasks/tasks/how-can-i-manage-comments-in-tallyfy/)**: Tallyfy's comment system enables comprehensive team discussions and collaboration directly within tasks with features for adding editing deleting comments using @mentions managing guest visibility and providing status enquiries to maintain contextual communication throughout workflow execution. ## Comment management in Tallyfy You can add, edit, and delete comments on any task in Tallyfy - just click the speech bubble icon or open the task to see the comments section. Type your message, use @mentions to notify teammates, and hit post. ### Add comments to tasks :::note[Guest Comments] [Guests](/products/pro/documenting/guests/) assigned to a task can comment too - they just see their specific task, not the whole process. ::: ### Edit comments ### Delete comments ### Use @mentions Type `@` and start typing their name (like `@Jane Doe`). Pick them from the dropdown that appears. They'll get a notification instantly. :::warning[Mentioning grants visibility] When you @mention someone who doesn't have access to the process yet, Tallyfy automatically gives them visibility. Only tag people who should actually see the work. ::: ### Guest visibility Your team's comments are hidden from guests by default. To share a specific comment with a guest: Guests can always see their own comments. ### Comment reactions React to comments using emojis by clicking the smiley face icon below a comment. ### Effective commenting tips * Stay focused on the task at hand - save general discussions for process comments * @mention specific people when you need answers (they get notified instantly) * Use **bold** for key points or deadlines - it catches the eye * Include context: "Updated vendor list (see attachment)" beats just "Updated" ### Enquire about task status When you're looking at tasks in any list view, click the three dots menu (⋮) and select **Enquire about Status**. Tallyfy posts a status request that @mentions whoever's assigned. - **[Send email reminders](https://tallyfy.com/products/pro/tracking-and-tasks/tasks/how-can-i-send-email-reminders-in-tallyfy/)**: Tallyfy allows users to send instant email reminders to task assignees by clicking the menu icon next to any task and selecting Send Email Reminder which immediately notifies all assigned members and guests regardless of their notification preferences. ## Send email reminders To send an email reminder in Tallyfy, click the menu icon (...) next to any task and select **Send Email Reminder** - it instantly notifies all assignees. Simple as that. While Tallyfy automatically sends reminder emails based on each user's notification preferences, sometimes you need to nudge people right now. Maybe there's an urgent deadline. Or someone's stuck and needs a gentle push. That's where manual reminders come in handy. ### How do I send manual email reminders for tasks? ### What should I know about manual email reminders? Here's the thing about manual reminders: * They fire off immediately - no delay * Everyone assigned gets the email (both [members](/products/pro/documenting/members/) and [guests](/products/pro/documenting/guests/)) * These bypass personal notification settings - yes, even if someone turned off daily reminders * Go easy on the reminders. Nobody likes being nagged Want to tweak your automatic reminder settings instead? Check out [Manage Email Notifications](/products/pro/settings/personal-settings/how-can-i-manage-email-notifications-in-tallyfy/). - **[Advanced tab](https://tallyfy.com/products/pro/tracking-and-tasks/tasks/how-can-i-utilize-tallyfys-advanced-tab-features/)**: Advanced task options in templates provide powerful control over workflow behavior including automatic process launching when tasks complete requiring all assignees to finish before progression automatic launcher assignment mandatory task settings completion restrictions webhook emissions guest comment limitations unique step identification and task tagging for enhanced filtering and organization. ## Use advanced task options in templates The **Advanced** tab in your [template](/products/pro/documenting/templates/) step editor gives you powerful control over how tasks behave when processes run. You'll find these settings when editing any step - they're what turn basic workflows into smart, automated systems. Let's walk through each option: * **Launch another process when this task is complete**: Want to trigger another workflow automatically? Switch this **ON**. When someone completes this task, Tallyfy will kick off a different process from another template. You can launch it separately or inject its tasks right into your current process - think of it as nesting one template inside another at runtime. (Currently, variables don't pass between processes, but that's coming soon.) See [Launch another process guide](/products/pro/launching/launch-process-when-task-is-completed/). * **All assignees must complete this task**: Turn this **ON** when you need everyone's individual sign-off. The task won't move forward until every single assignee marks it complete. You'll see a counter like "1 of 3 completed" tracking progress. Here's what happens when you enable this: * A **lock icon** shows up next to assignees - only they can complete the task * Everyone sees a **completion counter** ("2 of 4 completed") so they know where things stand * Tallyfy posts an **automated comment** each time someone completes their part * The task stays open until the last person finishes * Guests can participate too - they'll see the counter and complete their portion just like members *Heads up: This only works with regular "Task" steps right now, not "Approve/Reject" steps.* * **Assign launcher automatically**: What if nobody's assigned to a step? This setting decides. * **ON**: The person who launches the process gets the task automatically * **OFF**: The task sits unassigned until someone claims it or gets assigned :::warning[Group assignment behavior] Got a group assigned to this step? Careful - if "Assign launcher automatically" is ON, the launcher becomes an **extra** assignee on top of the group. Both the group AND the launcher can work on the task. Don't want that? Turn this setting OFF for group-assigned steps. ::: * **Task is mandatory...**: Used to prevent tasks from being removed at launch. :::note[Deprecated Setting] You'll still see this option, but it's deprecated. We kept it around for older templates that rely on it. ::: * **Only assigned members can complete or edit this task**: Lock this task down. When **ON**, only assigned people can touch it - no one else can complete or edit it. Perfect for sensitive tasks or when you need strict control. (Admins can still edit everything though.) :::note[Admin override] Administrators bypass this restriction - they can always edit tasks. ::: ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-only-assigned-can-complete.png) * **Emit webhook when completed**: Need to notify another system? Switch **ON** to fire a [webhook](/products/pro/integrations/webhooks/) when this task gets done. Great for updating CRMs or triggering external workflows. * **Prevent guests from making or seeing comments**: Keep guest conversations limited. When **ON**, [guests](/products/pro/documenting/guests/) can't see or add comments on this task. They can still complete it - they just can't chat about it. :::note You can still hide individual comments from guests even when this is **OFF**. ::: * **Unique Step Alias**: This gives your step a permanent ID that never changes. You'll need this for API [integrations](/products/pro/integrations/) or webhooks - it's how external systems can reliably reference this specific step. * **Tags**: Label individual tasks for easy filtering. These task-level tags are separate from process tags. Super handy when you want to slice and dice your task views - filter by "urgent", "finance", or whatever categories make sense for your workflow. - **[Create a one-off task](https://tallyfy.com/products/pro/tracking-and-tasks/tasks/how-to-create-a-one-off-task-in-tallyfy/)**: One-off tasks in Tallyfy are standalone action items created by clicking the + Create button and choosing Create task allowing you to assign quick to-dos with deadlines without needing full process templates. ## Create a one-off task Click the **+ Create** button and choose **Create task** - that's it. You'll get a form where you can add task details, assign it to someone, and set a deadline. Perfect for those quick to-dos that don't need a full process template. One-off [tasks](/products/pro/tracking-and-tasks/tasks/) in Tallyfy are standalone action items. They're independent of [templates](/products/pro/documenting/templates/), which makes them incredibly flexible for urgent work or follow-up actions. ### Why are one-off tasks valuable for workflow management? Ever had a quick request land on your desk that doesn't fit any of your standard processes? That's where one-off tasks shine. You don't need to build a whole template just to assign someone a simple task. Maybe it's following up with a client, reviewing a document, or handling an unexpected request - these tasks let you track everything in Tallyfy without overcomplicating things. No more sticky notes or separate to-do apps. The best part? They work alongside your process-based workflows. Everything stays visible in one place. Here's the step-by-step process: - **Name**: What's the task about? Keep it clear. - **Type**: Pick your task type - Regular works for most things, but you've got Approve/Reject and other options too. Choose [Expiring](/products/pro/tracking-and-tasks/tasks/what-types-of-tasks-can-i-create-with-tallyfy/) for FYI items that auto-complete at deadline to prevent [task debt](/products/pro/tutorials/how-to/how-to-avoid-task-debt/). - **Description**: Add any instructions or context the assignee needs. - **Assignee**: Who's doing this? (You can skip this and assign it later - see the note below). - **Deadline**: When should this be done? This is your due date. - **Start Time**: When should work begin? Optional, but helpful for planning. - **Form Fields**: Need to collect data? Add [forms](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/). - **Advanced**: You can even link this task to a running process if needed. :::note[Creating unassigned tasks] Don't know who should handle this yet? No problem. Leave the assignee field empty and the task gets created as 'Unassigned'. You can find these tasks later using filters in the [Tasks view](/products/pro/tracking-and-tasks/tasks-view/). ::: :::note[Understanding start time vs deadline in one-off tasks] Here's something that trips people up - you can set two different times: - **Start time**: When someone should start working on this. Great for planning. - **Deadline**: When it needs to be done. Miss this and the task shows as overdue. The start time is just guidance (nobody's enforcing it), but the deadline? That's what matters for tracking. ::: ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-step3.png) ## What should I learn next? Got your first one-off task created? Nice work. Next, you might want to see how to [complete or reopen tasks](/products/pro/tracking-and-tasks/tasks/how-can-i-complete-or-reopen-tasks-in-tallyfy/) - because sometimes things need a second look. For bigger tasks, check out [subtasks](/products/pro/tracking-and-tasks/tasks/how-to-create-and-use-subtasks/) to break work into manageable chunks. Need to juggle multiple tasks? The [Tasks view](/products/pro/tracking-and-tasks/tasks-view/) is where you'll spend most of your time. - **[Create and use subtasks](https://tallyfy.com/products/pro/tracking-and-tasks/tasks/how-to-create-and-use-subtasks/)**: The checklist field type in Tallyfy allows users to break down tasks into smaller trackable subtasks with customizable completion rules where you can require either all items or just one item to be checked before the parent task can be completed. ## Use the checklist field to create subtasks You know how some tasks have multiple moving parts? That's where the **Checklist** [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) type comes in handy. It lets you break down any task into smaller, trackable subtasks. Perfect for when you need to keep tabs on several related actions within a single step. ### What are checklist subtasks? When you add a Checklist field to a task: - You create a list of items that belong to the parent task - Users check off each item as they go - You decide the rules - does someone need to check all items or just some? ### How do I create checklist subtasks in a template? ### How do checklist completion rules work (validation)? Here's the thing - you need to tell Tallyfy when a checklist is actually complete. You've got two options: * **Require 'at least one' item**: The checklist counts as done when *at least one* box gets checked. Great for when you're offering options or only need one action completed. * **Require 'all items'**: *Every* single box must be checked. Use this when all subtasks are non-negotiable. Pick whichever matches your workflow. ### How do I complete checklist subtasks when running a process? Working through a checklist? Simple: ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-complete-subtasks.png) ### What are best practices for using checklists as subtasks? Want your checklists to actually work? Here's what we've learned: * **Be crystal clear**: Each item should spell out exactly what needs doing * **Keep it manageable**: 3-7 items per checklist hits the sweet spot (trust me on this) * **Start with action verbs**: "Verify ID", "Upload document" - not "ID verification needed" * **Think about sequence**: Put items in the order people will actually do them * **Validation matters**: Really think about whether you need everything checked or just some items * **Don't skip the guidance text**: A little extra context never hurt anyone ### What are examples of effective checklists? **QA Check:** ```text - Check spelling - Verify links - Test on mobile ``` **Onboarding:** ```text - Send welcome pack - Schedule intro meeting - Grant system access ``` Checklists might seem simple, but they're incredibly effective at keeping work organized. You'll catch those small-but-important steps that often slip through the cracks. The result? Better task management and fewer "oops, I forgot" moments. - **[Report blockers and improvement feedback](https://tallyfy.com/products/pro/tracking-and-tasks/tasks/how-to-report-and-resolve-issues-in-tallyfy/)**: The workflow issue management system allows users to report task blockers through comment flags that notify all stakeholders and provide visual indicators while enabling resolution tracking and template improvement suggestions for continuous process optimization. ## Reporting and resolving workflow issues To report a problem or issue that blocks task completion, use the **Blocker** comment feature. Navigate to the task, add a comment, select the **Blocker** option (red flag icon), and explain the problem. To resolve the issue once fixed, find the blocker comment and click **Resolve**. ### Report task blockers When a task can't be completed due to an issue, report it as a blocker (previously called "report/resolve problem"): ### Resolve blockers Anyone involved with the task can mark a blocker as resolved: ### Find processes with unresolved issues To see running processes with active blockers: --- ### Suggest template improvements Add improvement comments directly on templates to make future processes better. #### Add improvement comments Important: These comments attach to the template step itself - they're not tied to any specific running process. #### View improvement comments If you can edit the template, here's how to see these suggestions: #### Act on improvement comments Template owners/editors can: * Mark comments as 'Read'. * Edit the template based on feedback. * 'Hide' addressed comments. * Reply for clarification. - **[Set default content for form fields](https://tallyfy.com/products/pro/tracking-and-tasks/tasks/how-to-set-default-content-for-form-fields/)**: Default content in Tallyfy form fields pre-fills values automatically when tasks or kick-off forms open using static text dynamic variables or system-generated values like dates to reduce data entry and maintain consistency while still allowing users to modify pre-filled values as needed across text fields selection fields and date fields. ## What is default content in form fields? Default content automatically pre-fills [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) with values when a [task](/products/pro/tracking-and-tasks/tasks/) or kick-off form opens. It's a real time-saver - reducing data entry and keeping things consistent across your [processes](/products/pro/tracking-and-tasks/processes/). You can use static text, dynamic [variables](/products/pro/documenting/templates/variables/), or system-generated values like today's date. And yes, users can still change these pre-filled values whenever they need to. ### Why should I use default content in form fields? - **Faster form completion**: Users spend way less time typing the same info over and over. - **Reduced errors**: Pre-filled content keeps formatting consistent and cuts down on typos. - **Better user experience**: Let's be honest - forms feel so much easier when they're already partially filled. - **Dynamic information**: Variables automatically pull in relevant data from earlier steps. No more copy-paste. - **Smart defaults**: Set the most commonly selected options to help people decide faster. ## Which field types support default content in Tallyfy? Not all [form field types](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) support default content. Here's what works: ### Text fields (Short text and Long text) Text fields give you the most flexibility - they're the workhorses of default content. - **Static text**: Pre-fill with standard phrases, instructions, or helpful examples. - **Variables**: Pull data from previous form fields or system variables. - **Mixed content**: Combine static text with variables (like "Request from `{{customer_name}}`"). ### Selection fields (Dropdown, Radio buttons, Checklist) Want to speed things up? Pre-select the options people pick most often. - **Default selections**: Choose the most common option and save everyone a click. - **Multiple defaults**: For checklists, you can pre-check several items at once. ### Date fields Date fields are smart - they calculate deadlines and timestamps automatically. - **Current date/time**: Sets to today's date. Simple. - **Relative dates**: Need something due next week? Use "today + 7 days". - **Variable dates**: Pull date values from earlier form fields. ### Which field types cannot have default content? Some field types can't have defaults - mostly for technical or security reasons. Here's why: - **File upload**: Can't pre-populate files (security thing - and honestly, would you want random files appearing?). - **Table**: Can't pre-fill table rows, though you do set up column headers during configuration. - **Assignee picker**: Can't pre-select specific users here, but don't worry - you can set default assignments at the step level instead. ## How do I configure default content for form fields? ### How to set default content for text fields ### How to set default selections for dropdown and radio buttons ### How to set default selections for checklists ### How to set default dates ## How can I use variables in default content? [Variables](/products/pro/documenting/templates/variables/) are where things get really interesting. They pull information from other parts of your process and drop it right where you need it. ### What types of variables can I use in default content? **Form field variables**: These grab data that someone entered in earlier steps. - Example: `{{customer_name}}` pulls in the customer name from a previous field. No retyping needed. **Kick-off form variables**: Info that was entered when the process first started. - Example: `{{request_type}}` shows whatever type was selected in the kick-off form. **System variables**: Tallyfy generates these automatically - they're always current. - `{{DATE}}`: Today's date - `{{TIME}}`: Current time - `{{TEMPLATE_NAME}}`: The template you're using - `{{PROCESS_NAME}}`: This specific process instance's name ### What are examples of effective variable usage? **Customer communication**: Here's a template that practically writes itself: ``` Dear {{customer_name}}, Thank you for your {{request_type}} request submitted on {{DATE}}. We will process this within 5 business days. ``` **Reference numbers**: Need unique IDs? Create them automatically: ``` {{TEMPLATE_NAME}}-{{DATE}}-{{customer_id}} ``` **Follow-up dates**: Keep track of deadlines without thinking: ``` Follow up with {{customer_name}} by {{deadline_date}} ``` ## What are best practices for default content? ### How to choose meaningful defaults - Pick the options people actually select most often for dropdowns and radio buttons. - Set default dates that match your real process timeline - not wishful thinking. - Pre-fill text fields with genuine examples or formats people can actually use. ### Why should I keep defaults flexible? - Users will change defaults if they need to - that's the whole point. Don't box them in. - Think of defaults as helpful suggestions, not rules. - Test with real users. If they're constantly changing your defaults, you've got the wrong defaults. ### How to use variables strategically - Mix static text with variables - you get consistency AND personalization. - System variables are perfect for timestamps and tracking info. - Reference earlier form fields to keep everything connected. Context matters. ### Considering your audience - **Internal forms**: Use shortcuts and abbreviations your team understands. - **External forms**: Provide clear, spelled-out options for customers. - **Repetitive processes**: Add complete defaults for frequently-used processes. ### How do I maintain and update default content? - Check your defaults every few months. Things change. - Listen when users complain - they're telling you what needs fixing. - If everyone's changing a default, just delete it. It's not helping. ## What are common use cases for default content? ### Customer service requests Want faster response times? Default content is your secret weapon. - **Default priority**: Set to "Medium" - let's be honest, most requests aren't actually urgent. - **Default category**: Pre-select your most common ticket type. Saves time. - **Response template**: Drop in a friendly greeting with the customer's name already filled in. Personal touch, zero effort. ### Approval workflows Nobody likes waiting for approvals. Smart defaults keep things moving. - **Default reviewer**: Match the reviewer to the request type. Finance requests go to finance team - simple. - **Due date**: "Today + 3 days" gives reviewers breathing room without dragging forever. - **Approval notes**: Give reviewers a template so feedback stays consistent and useful. ### Project initiation Starting new projects? Stop reinventing the wheel every time. - **Project prefix**: Combine template name + today's date. Instant project codes that actually make sense. - **Default team members**: Pre-select your usual suspects for each project type. They know they're on it. - **Timeline defaults**: Standard milestones based on the start date. Realistic timelines from day one. ### Document generation Here's where default content really shines - automated documents that don't feel robotic. - **Document title**: Mix project name + document type + date. Clean, searchable, organized. - **Author information**: Pull requestor details straight from the kick-off form. No more "who wrote this?" - **Version numbering**: Start everyone at "v1.0". Consistency across the board. The bottom line? Default content turns empty forms into smart, helpful starting points. Your team saves time, makes fewer mistakes, and still has total flexibility to customize when they need to. That's a win. - **[Manually show or hide tasks](https://tallyfy.com/products/pro/tracking-and-tasks/tasks/manually-show-hide-tasks/)**: Learn how to manually show or hide tasks in running processes to handle conditional workflows when selections change or to temporarily remove tasks that are no longer needed while maintaining workflow flexibility. ## How to manually control task visibility Click the **three dots (⋮)** menu on any task and select **Hide task** or **Show task** to control visibility in running processes. Simple as that. You'll use this feature when someone changes their mind halfway through a form - maybe they switch from "Corporation" to "LLC" and now you've got irrelevant corporate filing tasks hanging around. Or when your [automation rules](/products/pro/documenting/templates/automations/) didn't quite predict this specific scenario. Manual visibility control puts you back in charge. ## Prerequisites - Administrator or Standard user role - An active [process](/products/pro/tracking-and-tasks/processes/) with tasks - Understanding of [task types](/products/pro/tracking-and-tasks/tasks/what-types-of-tasks-can-i-create-with-tallyfy/) ## When to use manual show/hide Most users discover this feature after their first "oh no" moment. You know the one - someone picks Option A, fills out three tasks, then realizes they meant Option B. The old tasks? Still there, confusing everyone. Here's when you'll reach for manual visibility: - **Mid-process pivots**: Customer changes from "New Installation" to "Upgrade" after starting the process (happens more than you'd think) - **Automation hiccups**: Your perfectly crafted rules show tasks that shouldn't be there - yet - **Quick fixes**: That compliance task isn't needed for this specific client, but you can't delete it from the template - **Testing scenarios**: You're walking through different process paths without launching 15 separate test runs ## How to manually hide a task Let's hide that unnecessary task: Gone. The task disappears from view but Tallyfy keeps it in the process history - nothing gets lost. ## How to manually show a hidden task Changed your mind? Need that task back? Here's the rescue mission: ## Important considerations ### What happens to hidden task data? Nothing. That's the beauty of it. Hidden tasks keep everything - completion status, form data, file attachments, comments. If someone spent 20 minutes filling out a task before you hid it, their work is safe. The assignments stick too. When you unhide the task three days later, it's exactly as it was. ### Manual vs automation - who wins? You do. Manual visibility always beats automation rules. Here's what catches people: If you manually hide a task, it stays hidden even when automation conditions change. Let's say your automation would normally show a task when "Priority = High". You manually hid it. Someone changes priority to High. Task stays hidden. You'll need to manually show it again. ### How hiding affects your process The moment you hide a task, a few things happen. First, it vanishes from everyone's [task views](/products/pro/tracking-and-tasks/tasks-view/). Your completion percentage recalculates - if you had 10 tasks and hide one, you're now tracking 9. Smart move: hidden tasks don't count against deadlines either. No more red warnings for tasks that shouldn't exist. ## Best practices After working with hundreds of teams using manual visibility, here's what works: **Leave breadcrumbs.** Add a comment when you hide or show tasks. Six months later when someone asks "Why is the compliance task missing from the Johnson account?" you'll have an answer. Takes 5 seconds, saves 30 minutes of detective work. **Check your hidden tasks weekly.** Set a reminder. Hidden tasks have a way of being forgotten - and sometimes they shouldn't stay hidden forever. One client discovered 47 hidden tasks across their processes. Turns out their automation rules needed tweaking, not manual overrides. **Train your power users first.** Not everyone needs to know about manual visibility. But your process champions? They should understand when to use it versus fixing the automation. Quick rule: If you're hiding the same task type repeatedly, update your template automation instead. **Think twice before hiding.** Sometimes the real issue is your automation logic. We see teams manually hiding tasks every day when a simple automation rule update would solve it permanently. Manual control is powerful - use it for exceptions, not everyday scenarios. ## Common use case example Here's the classic scenario that drives everyone crazy: You're onboarding a new client. The intake form asks "Business Type" - Corporation, LLC, Partnership, or Sole Proprietor. Each choice triggers different paperwork tasks. Your client confidently selects "Corporation" and moves forward. Corporate filing tasks appear. Articles of incorporation. Board resolutions. The works. Ten minutes later: "Actually, we're an LLC." They change their selection, and yes, the LLC tasks show up. But those corporate tasks? Still sitting there, confusing everyone. "Do we need board resolutions?" No. "Why is it asking for articles of incorporation?" You know what to do: 1. Hide those corporate filing tasks - they're not wrong, just irrelevant now 2. The LLC tasks are already there thanks to your automation 3. Add a quick comment: "Client switched from Corp to LLC during intake" Done. Your team sees only LLC-relevant tasks. No confusion, no wasted time on corporate paperwork they don't need. And if the client changes their mind again? (It happens.) Those hidden tasks are one click away. - **[Paste cells into a Tallyfy table](https://tallyfy.com/products/pro/tracking-and-tasks/tasks/paste-cells-tallyfy-table/)**: You can directly paste spreadsheet data from Excel or CSV files into Tallyfy Table form fields by copying your data with headers and using the paste function which matches columns based on header names to efficiently transfer bulk data without manual retyping. ## Paste data from Excel/CSV into a Table form field If you have data in a spreadsheet (like Microsoft Excel or a CSV file) that you need in a Tallyfy **Table** [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/), you don't have to retype it. You can paste it directly. This feature saves significant time and reduces data entry errors. ### What should I know before pasting? * **Matching headers are crucial**: The column headers in your spreadsheet **must exactly match** the column headers configured in the Tallyfy Table field. Tallyfy will only paste data where headers match. If headers don't match, data for that column is ignored. * **Copy data**: Copy the spreadsheet data (including headers) to your clipboard (e.g., select the cells in Excel and copy them). ### How do I paste data into the Tallyfy table? The data from your clipboard will be added as new rows to the table, matching columns based on headers. Blank cells from your spreadsheet will result in blank cells in the Tallyfy table. This process maintains data integrity while enabling efficient bulk data entry. - **[Scanner and RFID integration for form fields](https://tallyfy.com/products/pro/tracking-and-tasks/tasks/scanner-and-rfid-integration/)**: Tallyfy is developing scanner and RFID integration that will allow barcode scanners and RFID readers to automatically fill form fields through keyboard wedge mode eliminating manual data entry for warehouse receiving employee time tracking quality control and asset management workflows. ## How scanners and RFID readers will work with Tallyfy form fields Scanner and RFID integration with Tallyfy form fields will work through keyboard wedge mode - your scanner acts like a keyboard, instantly filling form fields when you scan. This feature is currently in development and will enable automatic data capture without manual typing. Here's the thing - most businesses already use barcode scanners or RFID readers for inventory, asset tracking, or employee badges. Right now, you're probably typing those codes manually into Tallyfy. That's about to change. ## Current status and development timeline **Important**: Scanner and RFID integration is not available yet. We're actively working on this feature based on customer feedback. Our engineering team has completed the technical analysis and identified that no major infrastructure changes are needed. The implementation will use existing form field capabilities with enhanced input detection. You'll see this feature rolling out progressively - starting with basic keyboard wedge support, then adding advanced detection features. ## How the integration will work ### Direct keyboard wedge input (simplest approach) Your scanner will work just like typing on a keyboard. Click into any Tallyfy form field, scan your barcode or RFID tag, and watch the data appear instantly. No configuration needed on Tallyfy's side. Here's what you'll need to do: 1. Configure your scanner in USB HID (Human Interface Device) mode 2. Set it to add an Enter key after each scan 3. Focus on the Tallyfy form field you want to fill 4. Scan - data appears immediately Most USB scanners work this way out of the box. You can test it right now with Notepad - if you see text appear when you scan, it'll work with Tallyfy. ### Smart field detection (coming next) We're developing JavaScript-based detection that recognizes scanner input automatically. The system will know when data comes from a scanner versus manual typing by measuring input speed - scanners typically send characters in under 20 milliseconds, while humans type much slower. This means: - Scanned data can trigger automatic field advancement - Different barcode patterns can fill different fields - The system can validate scanner input in real-time For example, scanning an employee badge starting with "EMP" could automatically fill the assignee field, while a product code starting with "SKU" goes to the product field. ### Webhook integration for mobile scanners Not everyone has USB scanners at every location. That's why we're building webhook support for mobile scanning apps. Your phone becomes the scanner. The flow works like this: 1. Use any scanning app that supports webhooks (many free options exist) 2. Scan with your phone 3. App sends data to Tallyfy via webhook 4. Form field updates automatically 5. Real-time updates show the scanned data immediately This approach works great for field teams, remote workers, or locations where USB scanners aren't practical. ## Supported scanner types and configurations ### Hardware compatibility These scanner types will work with Tallyfy: - **USB barcode scanners** - Any HID-compatible model (99% of USB scanners) - **Bluetooth scanners** - Paired to your computer or mobile device - **RFID readers** - Must support keyboard wedge mode - **Mobile device cameras** - Through webhook-enabled apps - **2D/QR code scanners** - Same as barcode scanners ### Required scanner settings You'll configure these on your scanner (check your scanner's manual): - **Interface mode**: USB HID Keyboard or Bluetooth HID - **Suffix character**: CR (Carriage Return/Enter) or Tab - **Inter-character delay**: 5ms if you experience issues - **Prefix**: Optional, but useful for identifying scan source Quick test: Open any text editor, scan something. See text? You're ready. ## Real-world use cases we're designing for ### Warehouse receiving Picture this workflow: 1. Open the "Receiving" process in Tallyfy 2. Scan the pallet barcode - Pallet ID field fills automatically 3. Scan each item - they add to your items table 4. Scan the storage location QR code - location field updates 5. Process completes when you scan an "END" barcode No typing. No errors. Just scan and go. ### Employee time tracking Employees scan their badge at a kiosk. Tallyfy recognizes the employee ID pattern, creates a "Clock In" task, assigns it to that employee, and logs the timestamp. Clock out works the same way. Simple. ### Quality control checkpoints 1. Scan product serial number - loads the inspection checklist 2. Scan "PASS" or "FAIL" QR codes for each checkpoint 3. Scan inspector badge to sign off 4. System advances to next product automatically Each scan creates an audit trail. Management sees real-time quality metrics. ### Asset management Scan an asset tag, Tallyfy pulls up its history. Scan a location QR code on the wall, asset location updates. The system knows what's where without manual data entry. Perfect for IT equipment, tools, or medical devices. ## Technical implementation details ### Phase 1: Basic keyboard wedge support This is what we're building first: - Direct input into focused form fields - Support for all standard barcode formats - Tab/Enter suffix handling for field navigation - Works with existing form field types (text, number, tables) No special configuration needed. If your scanner works with other software, it'll work with Tallyfy. ### Phase 2: Enhanced detection system Next, we add intelligence: - Automatic scanner detection based on input timing - Pattern matching for different code types - Auto-routing to appropriate fields - Visual indicators showing scan readiness - Batch scanning support for multiple items The system learns your scanning patterns and optimizes the workflow accordingly. ### Phase 3: Advanced integration features Finally, the complete solution: - Webhook endpoints for external scanners - Mobile app scanning support - Real-time synchronization across devices - Offline scanning with sync when connected - Custom validation rules for scanned data ## Configuration and setup (when available) ### For IT administrators You won't need special software or drivers. The setup process: 1. Configure scanners in HID mode (usually default) 2. Test with any text editor first 3. Train users on which fields to scan into 4. Create naming conventions for your barcodes We'll provide detailed guides for popular scanner models like Zebra, Honeywell, and Symbol. ### For end users It's straightforward: 1. Click in the form field 2. Scan your barcode or RFID 3. Data appears instantly 4. Press Tab or let auto-advance move you to the next field That's the entire process. No training needed beyond "click and scan." ### For process designers You'll set up templates with scanner-ready fields: - Mark fields as "scanner input expected" - Configure auto-advance rules - Set validation patterns for different barcode types - Design the workflow around scanning efficiency Think about the physical flow - where are scanners located? What order makes sense for scanning? Design accordingly. ## Security and data validation ### Input validation Every scanned input goes through the same validation as manual entry: - Format checking (ensuring barcode patterns match expected formats) - Length validation - Character restrictions - Business rule validation Invalid scans get rejected immediately with clear error messages. ### Security measures We're implementing: - Rate limiting to prevent scan flooding - Input sanitization to prevent injection attacks - Audit logging of all scanner inputs - Permission-based field access (same as manual entry) Your data stays secure whether typed or scanned. ## Benefits over manual data entry Let's talk about why this matters: **Speed** - Scanning takes under a second. Typing a 12-digit code? 5-10 seconds if you're fast. Multiply that by hundreds of items daily. **Accuracy** - Humans make typos. Scanners don't. Especially with long alphanumeric codes, scanning eliminates transcription errors completely. **Efficiency** - Workers stay focused on their actual job, not data entry. Warehouse staff can receive shipments faster. Quality inspectors move through checkpoints quicker. **Audit trail** - Every scan gets timestamped and logged. You know exactly when something was scanned and by whom. ## Common questions about scanner integration ### Will my existing scanner work? If it works with Microsoft Word or Notepad, it'll work with Tallyfy. Most USB and Bluetooth scanners are compatible. ### Do I need special software? No. Scanners work through keyboard emulation. No drivers, no special software, no plugins. ### Can I use my phone as a scanner? Yes, through webhook-enabled scanning apps. Several free options exist for iOS and Android. ### What about RFID tags? RFID readers that support keyboard wedge mode work exactly like barcode scanners. Tap the tag, data appears in the field. ### How do I prevent scanning into the wrong field? The enhanced detection system (Phase 2) will recognize scan patterns and route data to the correct fields automatically. Until then, users click the field before scanning. ## Next steps and updates We're actively developing this feature. Here's what you can do now: **Prepare your hardware** - Ensure your scanners support HID mode. Test them with a text editor to confirm they work as keyboards. **Plan your workflows** - Think about where scanning would save time. Which processes involve manual code entry? Those are your targets. **Standardize your codes** - Consistent barcode formats make integration smoother. Consider prefixes like "EMP" for employees or "SKU" for products. **Stay informed** - Watch for updates in your Tallyfy dashboard. We'll announce beta testing opportunities for early adopters. (Want to be a beta tester? Contact our support team and mention your interest in scanner integration.) ## Technical support and resources When this feature launches, you'll have: - Scanner configuration guides for major brands - Video tutorials showing setup and usage - Troubleshooting documentation - Direct support for implementation We're committed to making this as smooth as possible. Your existing workflows won't change - they'll just get faster. Remember - this isn't about new technology. It's about making your existing scanners work seamlessly with Tallyfy. No complicated integrations. No expensive middleware. Just scan and go. - **[Task assignment options](https://tallyfy.com/products/pro/tracking-and-tasks/tasks/task-assignment-guide/)**: Tallyfy supports multiple task assignment methods including direct assignment to specific members role-based assignment to job titles and groups guest assignment for external collaborators and advanced features like conditional assignments bulk management and automated notifications to accommodate various organizational workflows and requirements. ## Task assignment in Tallyfy ### Task assignment types Tallyfy gives you several ways to assign tasks that work for different types of organizations and workflows: #### How does direct assignment to specific members work? Assign tasks directly to specific members of your organization: - **Individual assignment**: Assign to a specific person by name - **Multiple assignees**: Assign to multiple people who all need to complete the task - **Sequential assignment**: Set primary and backup assignees in order #### How does role-based assignment work? Assign tasks to roles instead of specific individuals: - **Job title assignment**: Assign to a job title (e.g., "HR Manager") - **Dynamic role assignment**: Assign based on who completed a previous task - **Group-based assignment**: Assign to members of a specific group #### How does guest assignment work? Assign tasks to people outside your organization: - **Email-based assignment**: Assign to any email address - **Guest link sharing**: Create a link that anyone can use to complete a task - **Guest form submission**: Allow guests to submit forms without having an account ### Assign tasks #### How do I assign tasks in templates? When creating or editing a template: 1. Select a step in your template 2. Click on the **Assignment** tab 3. Choose the assignment type from the dropdown menu 4. Select specific assignees or roles as needed 5. Configure additional options like due dates or notifications #### How do I reassign tasks in active processes? Who can reassign tasks depends on your role and the specific task. **Administrators**: Can reassign any task to anyone. To reassign a task (if you have permission): 1. Navigate to the task in the active process 2. Click the **Reassign** button 3. Select the new assignee 4. Add a comment explaining the reassignment if needed 5. Click **Save** to confirm If you need a task reassigned but don't have permission, add a comment to the task requesting reassignment and tag an administrator or HR team member ### Advanced assignment features Tallyfy offers advanced assignment capabilities for complex workflows: #### How do conditional assignments work? Set up rules to automatically assign tasks based on specific conditions: - Assign based on form field values - Change assignees based on process variables - Route tasks dynamically based on business rules #### How can I use bulk assignment? Manage assignments for multiple tasks at once: - Reassign all tasks from one person to another - Update assignments across multiple processes - Manage team workloads efficiently #### How do assignment notifications work? Configure how assignees are notified: - Email notifications when tasks are assigned - Custom notification messages - Reminder settings for upcoming and overdue tasks ### Best practices for task assignment Follow these practices to make the most of Tallyfy's assignment capabilities: - **Be specific**: Clearly define who needs to do what - **Use role-based assignments** when possible to make templates more flexible - **Set reasonable deadlines** for task completion - **Include clear instructions** so assignees understand what's expected - **Avoid overloading** individuals with too many concurrent tasks - **Consider expertise and workload** when assigning tasks - **Use backup assignees** for critical tasks to prevent bottlenecks - **Review and adjust** assignments based on performance data ### How do I troubleshoot common assignment issues? | Issue | Solution | |-------|----------| | Unassigned tasks | Set default assignees in templates or use required assignments | | Reassignment needed | Enable task reassignment permissions for team leads | | Assignee unavailable | Set up backup assignees or use role-based assignment | | Unclear responsibilities | Use detailed task descriptions and clear assignment labels | | Too many notifications | Configure notification settings to reduce email volume | | Guest can't access task | Check guest permissions and resend invitation if needed | ### Examples of effective task assignment strategies Here are some real-world examples of effective task assignment strategies: **Example 1: Approval workflow** - Initial submission: Assigned to department members (role-based) - First approval: Assigned to department manager (job title) - Final approval: Assigned to specific executive (direct assignment) **Example 2: Customer onboarding** - Document collection: Assigned to the customer (guest assignment) - Document verification: Assigned to onboarding specialist (direct assignment) - Account setup: Assigned to IT department (group assignment) - Welcome call: Assigned to the sales representative who won the account (dynamic assignment) - **[Escalating overdue tasks](https://tallyfy.com/products/pro/tracking-and-tasks/tasks/task-escalation-for-overdue-items/)**: Tallyfy is developing automatic escalation features for overdue tasks including automated comments reassignments and custom notifications while current workarounds involve manual comments daily digest emails filtering capabilities and watch functions alongside research-backed best practices that emphasize supportive informational approaches over controlling threat-based reminders to maintain motivation and effectiveness. ## Manage task escalation for overdue items Keeping track of overdue tasks and making sure people stay accountable is a key part of managing Tallyfy processes well. Without proper management, overdue tasks accumulate into [task debt](/products/pro/tutorials/how-to/how-to-avoid-task-debt/) that can overwhelm your team. We're working on automatic escalation features for overdue tasks - think smart automated responses like adding comments and reassigning tasks when deadlines pass. This keeps workflows moving and people accountable while preventing task buildup. :::note[Understanding overdue tasks] A task becomes overdue when it passes its **deadline** - the date and time when work should be **complete**. This is different from the start time, which suggests when work should **begin** on a task. Overdue status is determined solely by whether the deadline has passed, regardless of the start time. ::: ### What automatic escalation features is Tallyfy developing? We've got some pretty cool automatic escalation features in the works for managing overdue tasks. Here's what's coming: - Automatically add comments to overdue tasks - Reassign tasks to managers or other team members when they become overdue - Set up custom notification rules based on how overdue a task is In the meantime, there are several ways you can handle overdue tasks right now. ### Current workarounds for escalating overdue tasks Here's what you can do today to manage and track overdue tasks: - **Add comments manually**: You can quickly add a comment on any overdue task to ask for status updates - **Daily digest emails**: Every member already receives daily digest emails that highlight overdue tasks - **Filter for overdue tasks**: Use the [Tracker view](/products/pro/tracking-and-tasks/tracker-view/) and [Tasks view](/products/pro/tracking-and-tasks/tasks-view/) to filter for overdue tasks only - **Watch specific items**: You can "Watch" a process or a task to receive notifications for all changes made to it. Note that this currently does not generate a notification when a task becomes overdue ## Research on effective task follow-up approaches Recent research across psychology and organizational studies offers valuable insights into effective approaches for managing overdue tasks. ### Summary of research findings Research indicates that threat-based, status-driven notifications—such as blunt reminders that "this task is overdue"—reflect a controlling communication style that undermines intrinsic motivation, damages performance, and leads to more negative evaluations of employees. In contrast, autonomy-supportive approaches—offering informational feedback, asking open-ended questions about why a task is late, and providing context-sensitive, actor-specific reminders—have been shown to boost engagement, task completion, and well-being. These patterns hold across cultures and industries, underscoring the global applicability of supportive, contextual strategies for managing overdue work. ### Theoretical foundations #### Self-Determination Theory (SDT) Self-Determination Theory posits that fulfilling basic psychological needs—autonomy, competence, and relatedness—fosters autonomous motivation, while thwarting these needs via controlling practices leads to controlled motivation and amotivation. A large meta-analysis of SDT-based interventions confirms that controlled motivational contexts negatively affect engagement and well-being across educational and work settings. #### Cognitive Evaluation Theory (CET) Cognitive Evaluation Theory, a subtheory of SDT, distinguishes between **informational** feedback (which supports autonomy and competence) and **controlling** feedback (which undermines them). Empirical work shows that even positive feedback delivered in a controlling manner (e.g., "You must keep up this pace!") reduces intrinsic motivation, whereas informational feedback preserves or enhances it. ### Empirical evidence #### Educational settings In a seminal study, Butler & Nisan (1986) randomly assigned students to receive either non-threatening, task-related comments, normative grades, or no feedback. Those receiving **task-related comments** maintained higher intrinsic motivation and performed better on creative and analytic tasks, whereas **normative grades** (a controlling cue) did not sustain interest any more than no feedback. #### Organizational settings Hardré & Reeve (2009) trained 25 Fortune 500 managers in autonomy-supportive strategies (e.g., providing rationales, non-controlling language). Five weeks post-training, these managers exhibited markedly more supportive behaviors, and their 169 employees reported higher autonomous motivation and greater workplace engagement compared to a control group. #### Modern technological interventions Microsoft's **Nudge** system uses machine-learning models to predict which pull requests are likely to stall, identifies the actor blocking progress, and sends tailored reminders. In large-scale trials, Nudge reduced pull request resolution time by **60%** compared to generic overdue notifications, and **73%** of recipients perceived the reminders as useful. ### Practical recommendations When following up on overdue tasks, consider these research-backed approaches: - **Ask "Why?"** - Use open-ended questions (e.g., "Can you share what obstacles you've encountered?") to diagnose root causes and demonstrate empathy - **Provide informational rationales** - Explain the importance and context of tasks (e.g., "Completing this report helps the team meet client expectations on time") - **Use non-controlling language** - Avoid "must" or "should"; instead, frame suggestions as options or invitations (e.g., "You might consider…") - **Tailor notifications with context** - When possible, personalize follow-ups rather than sending blanket overdue alerts - **Train managers in autonomy-support** - Implement theory-based approaches to teach autonomy-supportive behaviors By shifting from threat-based, status-driven reminders to supportive, informational approaches that respect team members' autonomy and competence, you can more effectively manage overdue tasks and foster a healthier, more motivated work culture. ## Best practices for following up on overdue tasks While waiting for automated escalation features, you can implement these best practices for effective follow-up: 1. **Be consistent** - Check for overdue tasks at regular intervals 2. **Understand before acting** - Ask about barriers or blockers before assuming negligence 3. **Offer help** - When following up, ask if assistance is needed to move the task forward 4. **Document follow-ups** - Use [comments](/products/pro/tracking-and-tasks/tasks/how-can-i-manage-comments-in-tallyfy/) to maintain a record of all follow-up communications 5. **Set clear expectations** - When extending deadlines, establish new, realistic timeframes :::tip[Reminder] Remember that the most effective follow-ups focus on removing obstacles and providing support, not just pointing out that something is late. ::: ## Preventing task debt before escalation Rather than constantly escalating overdue tasks, consider preventing the problem entirely: - **Use expiring tasks** for FYI items and optional information sharing. [Expiring tasks](/products/pro/tracking-and-tasks/tasks/what-types-of-tasks-can-i-create-with-tallyfy/) auto-complete at deadline, preventing buildup of non-critical overdue items. - **Bundle related work** into single tasks with multiple form fields instead of creating numerous small tasks - **Set realistic deadlines** based on actual completion patterns rather than optimistic estimates - **Audit task necessity** regularly - remove tasks that consistently go overdue without consequences See our guide on [how to avoid task debt](/products/pro/tutorials/how-to/how-to-avoid-task-debt/) for detailed strategies. - **[Step types](https://tallyfy.com/products/pro/tracking-and-tasks/tasks/what-types-of-tasks-can-i-create-with-tallyfy/)**: Tallyfy distinguishes between process steps that are part of workflow templates and one-off standalone tasks while offering five task types including standard tasks and approve/reject decisions and expiring tasks that auto-complete and email drafts requiring review and auto-send emails for scheduled notifications. ## Types of tasks in Tallyfy ### What's the difference between one-off tasks and process steps? Tallyfy handles different types of tasks depending on whether they're part of a workflow or standalone items. Here's how it breaks down: * **Process Steps/Tasks**: Defined within a [template](/products/pro/documenting/templates/) as 'Steps', becoming 'Tasks' when the [process](/products/pro/tracking-and-tasks/processes/) runs. They are part of a larger workflow. * **One-Off Tasks**: Standalone to-dos not linked to a template. Use them for quick actions or unique situations. * You can [create one-off tasks individually](/products/pro/tracking-and-tasks/tasks/how-to-create-a-one-off-task-in-tallyfy/). * You can [add them to a running process](/products/pro/tracking-and-tasks/processes/edit-processes/how-can-i-add-tasks-to-active-processes-on-tallyfy/) (ad-hoc tasks). * You can link a one-off task to a specific template or process if needed. :::tip[Adding ad-hoc tasks to active processes] You aren't limited to the tasks included when a [process](/products/pro/tracking-and-tasks/processes/) launched. You can add ad-hoc tasks to handle unique situations without modifying the original [template](/products/pro/documenting/templates/). Template creators can control this via **Settings > Permissions** in the template editor using the **"Can people add one-off tasks to this process?"** setting (default is "Yes"). If set to "No", only Admins can add ad-hoc tasks, useful for compliance-critical processes. ::: ### Tallyfy step/task types Whether you're creating a step in a template or a one-off task, you've got five types to choose from: | Type | Main Button(s) | Must be Completed? | Description & Common Uses | |---------------------|--------------------|--------------------|-----------------------------| | **Task** | COMPLETE | Yes | Standard to-do. Use for most actions (data entry, reviews). | | **Approve/Reject** | APPROVE / REJECT | Yes | For decisions. Use for approvals (finance, design). Can trigger [Automations](/products/pro/documenting/templates/automations/). | | **Expiring** | COMPLETE | No (Optional) | Auto-completes at deadline if not done. Use for optional reminders/updates (e.g., weekly reports). Prevents overdue task build-up. | | **Email Draft** | SEND | Yes | Creates email draft for assignee review/edit before manual send. Use for updates needing human checks. | | **Email Auto-Send** | SEND NOW / (Auto) | Yes | Sends pre-written email automatically at deadline (or earlier via **SEND NOW**). Use for scheduled reminders/notifications. | #### Task type This is the standard type, requiring the assignee to click **COMPLETE**. #### Approve/Reject type This type shows two buttons. Use [Automations](/products/pro/documenting/templates/automations/) to trigger different actions based on the **APPROVE** or **REJECT** choice. :::tip[Restricting approvals] You can ensure only assigned users approve/reject by enabling "Only assigned members can complete..." in the task's **Advanced** tab (Admins can always override). ::: #### Expiring type Useful for tasks that are helpful but not critical if missed. They complete automatically at the deadline, preventing your task list from filling with old, non-essential overdue items. Think of it like the famous scene in Mission Impossible where the message says "This message will self-destruct in 5 seconds." An expiring task works the same way - if nobody acknowledges it by the deadline, it automatically completes itself and disappears from active task lists. Perfect for information sharing without creating [task debt](/products/pro/tutorials/how-to/how-to-avoid-task-debt/). Use expiring tasks to: - Share FYI updates that don't require action - Distribute optional resources or training materials - Send weekly status reports for awareness - Provide non-critical announcements Team members get notified and can engage if they want, but the task won't pile up if they don't. This respects that not everything needs active completion - sometimes you just need to make information available. #### Email types * **Email Auto-Send**: Write the email in the template. It sends automatically at the deadline unless someone clicks **SEND NOW** earlier. * **Email Draft**: Write a draft in the template. The assignee reviews/edits and clicks **SEND** manually. * **Email Branding Options**: Both email types can send with or without Tallyfy branding. By default, emails include the Tallyfy logo, header, and footer with action buttons. Enable the **"Send Chromeless"** option to send plain emails without any Tallyfy branding - useful when emails should look like standard messages from regular email clients rather than workflow notifications. * **Email Copies**: The sender (or Tallyfy for auto-send) usually gets a copy, unless they disabled specific email notifications. :::note[Receiving email copies] Receiving copies depends on the "Receive emails when I'm assigned" setting under **Settings > My Profile > Email Notifications**. See [Manage Email Notifications](/products/pro/settings/personal-settings/how-can-i-manage-email-notifications-in-tallyfy/). ::: - **[Types of form fields](https://tallyfy.com/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/)**: Tallyfy offers various form field types including short text long text dropdown lists checklists radio buttons date pickers file uploads tables and assignee pickers that collect user input to modify smart process flows through variables and automations with options for validation requirements and guidance text. ## Form field types in Tallyfy Tallyfy form fields are how smart processes ask for user input. This user input can then modify the flow based on what users enter or select. You can add form fields to the **Kick-off Form** (filled before the process starts) or to individual tasks throughout the process. This creates intelligent workflows that adapt based on user responses. :::tip[Form fields create variables] Remember that user input collected through these fields becomes data that smart processes use to modify their flow via [variables](/products/pro/documenting/templates/variables/) and [automations](/products/pro/documenting/templates/automations/). ::: Here are the different types of form fields you can use to ask for user input. :::note[Required vs. optional] You can mark most fields as required (must be filled) or optional. Smart processes can use either type to modify their flow. Checklists use validation rules instead. ::: :::note[Guidance text] All field types allow adding extra help text (Guidance Text) below the label to guide users on what input the smart process needs. ::: ### How do different field types work? #### Short text * Single line for short user input (up to 200 characters). * Smart processes can use this input to modify flow (e.g., different paths for different company names). * **Options**: Enforce validation (e.g., must be number, email, URL), min/max length, prefix/suffix (e.g., $, kg). * **Tip**: Use short text fields to store [file request links](mdc:products/pro/integrations/document-management/file-request-links/) from your document management system for secure external file collection. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-short-text-field.png) #### Long text * Larger box for detailed user input (up to 6,000 characters). * **Options**: Enable rich text formatting (bold, lists). * Use for collecting descriptions, notes, or feedback that can influence how the process flows. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-long-text-field.png) :::tip[Rich text copy/paste behavior] **When pasting from Microsoft Word or other applications**, formatting is intentionally stripped to prevent non-compliant HTML. After pasting, use the formatting toolbar to reapply styles. **Preserving complex formatting**: - **Option 1**: Use "Show HTML" toggle to paste raw HTML (ensure proper formatting) - **Option 2**: Use an online HTML editor, then copy clean HTML into Tallyfy - **Option 3**: Set up [global branding CSS](/products/pro/settings/org-settings/how-can-i-personalize-my-tallyfy-branding-and-emails/) for consistent styling This behavior prevents broken layouts and ensures content displays correctly across all devices. ::: #### Dropdown list * Asks users to pick **one** option from a list - smart processes often modify their flow based on this selection. * **Options**: Define list items, set default. * Perfect for when user input should trigger different workflow paths (e.g., select department determines approvers). * **Important**: When reordering dropdown options in the template editor, click the save button explicitly. Changes won't persist if you navigate away without saving - refreshing the page will lose your reordering. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-dropdown-list.png) #### Checklist * Lets users check **one or more** items - smart processes can modify flow based on what's checked. * **Options**: Define list items, set defaults, validation (require 'at least one' or 'all items'). * Use for requirements lists where checked items determine next steps. See [Create Subtasks](/products/pro/tracking-and-tasks/tasks/how-to-create-and-use-subtasks/). ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-checklist-field.png) #### Radio buttons * Asks users to pick **only one** option - ideal for smart processes that branch based on user choice. * **Options**: Define list items, set default. * Perfect for Yes/No decisions or priority levels that modify how the process flows. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-radiobuttons-field.png) #### Date * Lets users pick a date (and optionally time) from a calendar. * **Options**: Set default date (e.g., today, today + 7 days). * Use for deadlines (when work should be complete), start dates (when work should begin), meeting dates, and other date-based information. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-datetime-field.png) #### File upload * Lets users upload file(s) (up to 100MB each[^2]). * **Options**: Set as required. * Use for collecting docs, images, reports. * **Alternative**: For sensitive documents or larger files, consider using [file request links](mdc:products/pro/integrations/document-management/file-request-links/) from your existing document management system instead. * **Multiple files**: Click and select multiple files at once, or add files one by one - the field supports multiple uploads ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-file-upload-field.png) #### Table * Create a table with columns you define. Users add rows of data. * **Options**: Define column headers. No default content. * Use for collecting structured lists (e.g., order line items, attendee lists). * **Adding Columns**: When setting up the field in the template editor, click **Add New Column** to define the structure. * **Using in Tasks**: When the task is active, users click **Add Row** to enter data into the table you defined. * **Using with Variables**: You can insert the entire table's data into a later step description using the [Insert Variable](/products/pro/documenting/templates/variables/how-can-i-use-insert-variables-in-tallyfy/) feature. * **Using in Rules**: You can create [automation rules](/products/pro/documenting/templates/automations/) that check if a specific column within the table **Contains** a certain value. #### Assignee picker * Lets user select a Tallyfy member or group. * **Options**: Set as required. * Use when the person doing a later task needs to be chosen during the process. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-assignee-picker.png) :::important[Assignee picker captures data but doesn't auto-assign] **The assignee picker field captures who was selected but does NOT automatically reassign tasks.** To actually use the selected assignee, you must create an automation rule: 1. Add the assignee picker field to your step 2. Go to **Automations** in your template 3. Create a rule with: - **IF condition**: When the step with assignee picker is completed - **THEN action**: Assign/unassign specific tasks - Use the assignee picker field value to determine assignment **Common use case**: Manager selects team member in Step 1 using assignee picker → Automation assigns Step 2 to that selected person. Without the automation rule, the selection is just stored data - it won't change any task assignments. ::: ### Form field limitations :::note[Calculations not supported] **Tallyfy form fields don't support automatic calculations** like formulas (e.g., Unit Price × Quantity = Total). **Workarounds for calculations**: 1. **External calculation** - Have users calculate values externally and enter the result 2. **Instructions in guidance text** - Provide calculation instructions in the field's guidance text 3. **Use automation rules** - Create conditional logic based on entered values to route to different steps 4. **Integration with calculation tools** - Use webhooks or API to send data to external calculation services 5. **Multiple fields** - Collect components separately (price, quantity) and calculate in reporting For complex calculations, consider integrating with spreadsheet tools via Zapier or using the API to process data externally. ::: :::tip[Deleting form fields with rule dependencies] **Can't delete a form field?** If a field is referenced in automation rules in other steps, you must delete those rules first. To troubleshoot: 1. Check all automation rules in your template 2. Look for any rules that reference the field you want to delete 3. Delete or modify those rules first 4. Then delete the form field This prevents broken automations from fields that no longer exist. ::: ### What other field settings are available? Most fields also have these settings available when setting them up: * **Name**: Field label (the question your smart process asks). * **Guidance**: Optional help text below the label to clarify what input will modify the flow. Add this in the **Advanced** section of the field settings within the template editor. It appears in italics below the field name when the task is active, and any URLs included become clickable links. * **Field Alias[^1]**: Unique internal ID for integrations and automations that modify flow based on user input. It is automatically generated based on the *first* name you give the field and **does not change** even if you edit the field name later. This ensures that automations using the alias continue to work. * **Required**: Mark if this user input is required before task completion. * **Default Value**: Set default value (can use variables for text fields). See [Set default content for form fields](/products/pro/tracking-and-tasks/tasks/how-to-set-default-content-for-form-fields/) for detailed instructions. Remember, user input from form fields enables smart processes to ask questions and modify their flow based on responses, ensuring every workflow adapts to specific situations. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-show-not-required-field.png) [^1]: System-generated ID frozen after creation, safe for API/webhook integrations even if field renamed [^2]: Single file limit; multiple files can be uploaded but each must be under 100MB individually - **[Edit tasks](https://tallyfy.com/products/pro/tracking-and-tasks/tasks/edit-task/)**: Task editing allows users to modify assignees add media use rich text descriptions and adapt work requirements to ensure tasks stay relevant and actionable as situations change throughout their lifecycle. ## Options for editing tasks You can edit any [task](/products/pro/tracking-and-tasks/tasks/) in Tallyfy - change who's assigned, update descriptions, add videos or images, and adjust due dates. Works for both standalone tasks and tasks inside running [processes](/products/pro/tracking-and-tasks/processes/). Need to reassign work because someone's out sick? Update task descriptions when requirements change? Add a quick video to clarify instructions? That's exactly what task editing is for. You'll find the rich text editor particularly helpful for formatting descriptions, adding bullet points, or highlighting important details. ### Edit task - **[Add videos to a task](https://tallyfy.com/products/pro/tracking-and-tasks/tasks/edit-task/how-can-i-add-videos-to-my-tallyfy-process/)**: You can add videos to task descriptions in Tallyfy by either embedding links from video platforms like YouTube and Vimeo through the "Insert > Embed URL" option or by uploading video files directly with a 100MB limit using the "Insert > Video" feature. ## Add or embed videos in tasks To add videos to a [task](/products/pro/tracking-and-tasks/tasks/), you've got two options: embed from YouTube/Vimeo using **Insert > Embed URL**, or upload video files directly through **Insert > Video**. Most users prefer embedding - it's faster and doesn't eat up your storage. Need visual instructions for your team? Videos can transform confusing tasks into crystal-clear steps. Here's how to add them: 1. **Embed from Video Sites**: Link to videos on YouTube, Vimeo, or similar platforms 2. **Upload Video Files**: Upload MP4 or WebM files (up to 100MB) directly to Tallyfy ### Method 1: How do I embed videos from links? (recommended) Want the best video quality without hogging Tallyfy storage? Embedding is your friend. Your videos load faster, play smoother, and you don't have to worry about file size limits. :::tip[Many embed sources supported] Here's something cool - Tallyfy's "Embed URL" option works with hundreds of sources, not just videos. Think Figma designs, Google Docs, Typeform surveys... the list goes on. ::: ### Method 2: How do I upload video files? Sometimes you need to upload your own video files - maybe it's proprietary content or something you just recorded. No problem. Just keep an eye on that 100MB limit (yes, it catches everyone off guard at first). Stick with MP4 or WebM formats and you're golden. Quick tip? Go with embedded videos whenever you can. Your tasks load faster, and you won't burn through storage space. Save the uploads for when you really need them. - **[Assign members or guests after launching](https://tallyfy.com/products/pro/tracking-and-tasks/tasks/edit-task/how-can-i-assign-members-to-tasks-in-tallyfy/)**: Tallyfy allows you to assign tasks to members and guests at three different stages: during template creation when launching a process or while a process is running with options to set default assignees modify assignments during launch reassign tasks in active processes and control completion permissions through various assignment types and automation settings. ## Assigning members and guests to tasks You can assign [tasks](/products/pro/tracking-and-tasks/tasks/) in Tallyfy at three points: when building a [template](/products/pro/documenting/templates/), during [process](/products/pro/tracking-and-tasks/processes/) launch, or while the process is already running. ### Assign tasks in a template To set default assignees in your template: These defaults apply every time someone launches the process. You can change them during launch if needed. ### Assign tasks when launching a process During process launch, you can modify assignments: ### Assign or reassign tasks in a running process To change assignments in a running process: ### Unassigned tasks ("nobody assigned") Tasks without initial assignments: * These tasks show up with a generic icon and **"Nobody Assigned"** label. * You'll find them using the **"Assigned to nobody"** filter in the [Tasks view](/products/pro/tracking-and-tasks/tasks-view/). * Anyone with permission can grab them later - either assigning to others or claiming them personally. ### "Assign launcher automatically" setting This setting in the template step's **Advanced** tab determines what happens when there's no default assignee: * **If ON (Default)**: * No one assigned in the template? The process launcher gets it automatically. * Only guests assigned? Both the launcher and guests get assigned. * **If OFF**: * No one assigned in the template? Task starts as 'Nobody Assigned'. * Only guests assigned? Just the guests get it (launcher doesn't). ### Restrict task completion and editing To control who can complete or edit tasks: ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-only-assigned-can-complete.png) :::note[Admin override] **Administrators** can always complete or edit any task, regardless of this setting. ::: - **[The rich text editor](https://tallyfy.com/products/pro/tracking-and-tasks/tasks/edit-task/how-can-i-use-tallyfys-rich-text-editor-for-tasks/)**: Tallyfy's rich text editor functions as a built-in word processor that allows formatting text adding images videos and dynamic content while enabling the creation of pre-filled email links through HTML mode and variables for streamlined workflow communication. ## Use the rich text editor for tasks and descriptions Tallyfy's rich text editor appears wherever you type text - in task descriptions, comments, long text fields, and template descriptions. It's like having a mini word processor right inside Tallyfy. You can format text, add images, embed videos, and insert dynamic content. Here's what you can do: ### What basic formatting options are available? You'll find all the standard formatting tools in the toolbar: * **Bold** * *Italics* * Bulleted lists * Numbered lists * **Headings** (H2, H3, etc. - great for organizing longer content) ### How can I insert dynamic content (variables, snippets)? Look for these icons in your toolbar (they're usually on the right side): * **Insert Variable** (**{ }** icon): This pulls in information collected earlier in your process. Super handy. * Choose data from **Kick-off form fields**. * Choose data from **previous step fields** in the same process. * Choose **System variables** (like `Current TaskID`, `Current ProcessID`) - these are mostly for technical integrations. * Need more details? Check out [Using Variables](/products/pro/documenting/templates/variables/how-can-i-use-insert-variables-in-tallyfy/). * **Insert Snippet/Template** (**✂️** icon): Drop in reusable content blocks with a single click. * **Snippets**: These are saved blocks of text you use often. See [Using Snippets](/products/pro/documenting/templates/snippets/how-can-i-use-snippets-to-simplify-workflow-in-tallyfy/). * **Templates**: Link to another template right inside your current one. It's like nesting workflows - perfect for referencing standard procedures or compliance checklists within task descriptions. ### How do I use the "Insert" menu for media and elements? The **Insert** menu (usually on the left side of your toolbar) is where the magic happens: * **Insert Image**: Upload an image or link to one that's already online. * **Upload File**: Attach documents, spreadsheets, PDFs - whatever you need. * **Insert Video**: Upload video files (MP4, WebM, up to 100MB). *Pro tip: Use 'Embed URL' instead - it loads much faster.* More info at [Adding Videos](/products/pro/tracking-and-tasks/tasks/edit-task/how-can-i-add-videos-to-my-tallyfy-process/). * **Insert Link**: Create clickable web links. * **Insert Table**: Need a simple table? Done. * **Embed URL**: This one's powerful. Paste links from YouTube, Vimeo, Twitter, Google Maps, and tons of other sites. The content shows up right in your task. No clicking away needed. * **Page Break**: Add page breaks (you'll mainly use this in [Document templates](/products/pro/documenting/documents/)). ### How should I paste content from Word or Google Docs? Here's something that might surprise you - when you paste from Word or Google Docs: * **Most formatting disappears**: Tallyfy strips out fonts, colors, and fancy layouts. Why? It keeps everything looking consistent and prevents weird technical glitches. * **Best approach**: Paste as plain text first, then add formatting with the editor buttons. Takes an extra minute but saves headaches later. ### What are the differences between Tallyfy and Word documents? Tallyfy isn't Word - and that's actually a good thing. Here's what's different: * It's built for online workflows, not printing documents. * Those headings (H2, H3)? They automatically create a table of contents. Pretty neat. * Your organization's branding applies everywhere - no need to format each document. * Images from Word might look huge at first. Just resize them after pasting. * Instead of saving versions, Tallyfy tracks every change in activity logs. You can see who changed what and when. ### How can I create one-click email links using HTML mode? Want users to send pre-filled emails with a single click? You can create smart mailto: links in task descriptions using HTML mode and [variables](/products/pro/documenting/templates/variables/). When someone clicks the link, their default email client opens with everything already filled in - subject line, recipients, even the message body. Here's how it works: #### Prerequisites for mailto: links - Your organization must have **HTML authoring enabled** (check **Settings > Organization > Customization**) - You need variables set up in earlier steps if you want dynamic content - Users need a default email client configured on their device #### Creating a basic mailto: link In HTML mode, here's the structure: ```html Click to send status email ``` This creates a link that opens an email to recipient@example.com with "Task Complete" as the subject and a pre-written message. #### Using variables in mailto: links The real power comes from combining mailto: links with Tallyfy variables. Say you collected customer information in earlier steps - you can use that data in your email: ```html Email customer about order ``` **Note:** Use `%0A` for line breaks in the email body (that's URL encoding for a new line). #### Advanced mailto: options You can include multiple recipients, CC, BCC, and more: ```html Request approval ``` #### Common use cases for mailto: links - **Customer notifications**: Pre-fill order updates, appointment confirmations, or service completions - **Approval requests**: Generate emails with all context needed for quick approvals - **Status updates**: One-click reports to managers or clients with current process data - **Escalations**: Create urgent emails with all relevant case information included Remember - the email still opens in the user's email client where they can review and edit before sending. Nothing gets sent automatically, giving users full control while saving them tons of typing. ### Browser compatibility for mailto: links Mailto: links work differently across devices and browsers - here's what you need to know: **Desktop browsers (Chrome, Edge, Firefox):** Full support with a quick setup - Look for the protocol handler icon (double-diamond) in your browser's address bar - Click it and allow Gmail (or your preferred email service) to "open all email links" - From then on, clicking a mailto: link opens your chosen web email service - This uses the browser's `registerProtocolHandler` feature for seamless integration **Safari and mobile browsers:** Limited support - Safari on macOS doesn't support web-based protocol handlers - mailto: links will open your Mac's default mail app - Mobile browsers (iOS/Android) generally don't support web protocol handlers either - On mobile devices, mailto: links try to launch a native mail app, not web email - You'd need a native app (like the Gmail app) set as your default email handler **Workaround for universal access:** If you control the link creation and know users primarily use Gmail, you can skip mailto: entirely and use Gmail compose URLs directly (see section below). ### HTML formatting not supported in mailto: links **Important limitation:** Mailto: links can only pre-fill plain text - no HTML formatting is possible. According to the mailto: specification (RFC 6068), the `body=` parameter is strictly for "the first text/plain body part." This means: - No bold, italics, or other rich text formatting - No hyperlinks or clickable URLs within the email body - No tables, images, or other HTML elements - Any HTML tags you include will appear as literal text, not formatted content **Working with plain text:** - Use line breaks with URL encoding: `%0D%0A` represents a new line - Example: `mailto:user@example.com?body=Line%201%0D%0ALine%202` creates two separate lines - Structure your content with spacing and plain text formatting (dashes, asterisks, etc.) - Keep messages clear and concise since formatting options are limited If you need rich HTML emails, you'll need to either: - Use server-side email sending where you control the MIME type and can include HTML - Direct users to a web form that sends formatted emails on the backend - Have users manually format the email after it opens in their client ### Alternative: Gmail compose URLs for web-only workflows If your team primarily uses Gmail on the web, you can create direct Gmail compose URLs instead of mailto: links. These bypass the mailto: protocol entirely and open Gmail's compose window directly. **Gmail compose URL structure:** ``` https://mail.google.com/mail/?view=cm&fs=1&to=recipient@example.com&su=Subject&body=Message ``` **Parameters you can use:** - `to=` - Recipient email address - `cc=` - CC recipients (comma-separated for multiple) - `bcc=` - BCC recipients - `su=` - Subject line - `body=` - Message body (plain text only, URL-encoded) **Example with variables:** ```html Email customer via Gmail ``` **Limitations of Gmail compose URLs:** - **Plain text only** - Just like mailto:, the body parameter doesn't support HTML formatting - **Gmail-specific** - Only works for users who use Gmail (won't work with Outlook, Yahoo, etc.) - **Web-only** - Opens in a browser tab, not a desktop email client - **Authentication required** - Users must be logged into Gmail **When to use each approach:** - **Use mailto:** When users have various email clients and you want universal compatibility - **Use Gmail URLs:** When you know all users use Gmail and want to avoid mailto: handler issues - **Use server-side:** When you need HTML formatting, attachments, or guaranteed delivery For teams using Gmail exclusively, the compose URL approach eliminates compatibility issues while still providing one-click email creation with pre-filled content. ### Tracker view - **[Check process activity](https://tallyfy.com/products/pro/tracking-and-tasks/tracker-view/how-can-i-track-process-activities-on-tallyfy/)**: Tallyfy processes maintain detailed activity logs that record all actions including task completions deadline changes and comments which can be accessed through the Settings panel's Activity tab where events are displayed with the most recent at the top and timestamps shown in your local timezone. ## View the activity log for a process Each running Tallyfy [process](/products/pro/tracking-and-tasks/processes/) keeps a detailed log of everything that happens within it. This Activity log helps you track progress, see who did what, and troubleshoot problems. It records actions like: * Task completions or re-opens. * Deadline changes. * Comments added. * Process archiving/unarchiving. * And more. ### How do I view the process activity log? 1. Open the running process you want to view (e.g., from the **Tracker** view). 2. Click the **Settings** button (gear icon ⚙️) in the top right corner of the process view. 3. In the panel that opens, click the **Activity** tab. 4. Scroll through the log to see the action history; the most recent events are at the top. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-check-process-activity.png) :::note[Activity timestamp display] Process activity timestamps are stored on our server in ISO 8601 format without timezone information. In the Tallyfy interface, these timestamps are automatically converted to display in your personal timezone setting, ensuring you see accurate local times while maintaining consistent data storage. ::: :::note[Permissions] Only **Administrators** and [members](/products/pro/documenting/members/) with permission to view the process can see its Activity Log. ::: - **[Manage and track my processes](https://tallyfy.com/products/pro/tracking-and-tasks/tracker-view/how-can-i-manage-and-track-my-processes-on-tallyfy/)**: Tallyfy's Tracker view offers centralized process management through visual cards displaying key information like status due dates and assignments with comprehensive sorting filtering and color-coded status indicators to monitor workflow progress and identify issues across your workspace. ## Manage and track processes The **[Tracker](/products/pro/tracking-and-tasks/tracker-view/)** view (accessible through the left sidebar) provides complete high-level oversight of all running [processes](/products/pro/tracking-and-tasks/processes/) across your Tallyfy workspace. This interface enables workflow monitoring, status tracking, and progress oversight through visual displays and organizational tools. ### What information does the Tracker view display? ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-showcase-tracker-tab.png) * Each running process appears as a card. * Each card shows key info like the process name, source template, current status (e.g., On-time, Due soon, Overdue), tasks completed, the next due date, and who is assigned the next task. ### How can I sort and filter processes in the Tracker? The Tracker provides organization features for customized process display based on specific criteria: * **Sorting**: Use the sort dropdown (usually top right) to order processes by Due Date, Newest/Oldest, or alphabetically by name (A-Z or Z-A). ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-order-processes.png) * **Filtering**: Use the **Add Filter** button to show only processes matching criteria (e.g., processes with issues, processes in a folder, processes with specific tags). See [Customize the Tracker View](/products/pro/tracking-and-tasks/tracker-view/how-to-create-custom-views-in-tallyfy/). ### How do I understand process status colors? Tallyfy uses colors or labels to indicate process status: * **On-time**: Running normally, no deadlines missed. * **Due soon**: One or more tasks are due very soon (e.g., within 24 hours). * **Overdue / Problem**: A task deadline is missed, or someone reported a blocker. - **[Create custom views](https://tallyfy.com/products/pro/tracking-and-tasks/tracker-view/how-to-create-custom-views-in-tallyfy/)**: Tallyfy's Tracker allows users to create custom filtered views called "Presets" by applying specific filters and saving them for quick future access to relevant process subsets. ## Create custom views in Tracker The Tallyfy **[Tracker](/products/pro/tracking-and-tasks/tracker-view/)** view displays running processes, but custom filtered views (called "Presets") enable rapid access to specific process subsets based on defined criteria. Custom views improve workflow management by providing instant access to relevant processes. For example, you could create a preset displaying processes assigned to your team, tagged "Urgent", and approaching deadline requirements, enabling focused attention on critical work items. To create and save a custom view preset: Your saved preset view will now appear (e.g., as a clickable name or tab) in the Tracker view, allowing you to quickly re-apply that filter combination in the future. This feature enables efficient workflow management by providing instant access to frequently needed process views. - **[Switch between views](https://tallyfy.com/products/pro/tracking-and-tasks/tracker-view/how-to-switch-between-board-and-table-formats-in-tallyfy-tracker/)**: Tallyfy Tracker offers two view formats - Board View displays processes as visual cards with grouping options while Table View presents processes in customizable tabular format and you can switch between them using the Board and Table buttons in the top right area of the interface. ## Switch between board and table formats The **[Tracker](/products/pro/tracking-and-tasks/tracker-view/)** provides two distinct display formats optimized for different workflow management preferences and use cases. These complementary view formats accommodate diverse working styles and information needs: * **Board View** (Default): Displays processes as visual cards with optional grouping capabilities (e.g., organized by status, priority, or assignee) * **Table View**: Presents processes in structured tabular format with customizable column configurations for detailed data analysis ### How do I switch between views? 1. Go to the **Tracker** view from the left sidebar. 2. Find the buttons or tabs (usually near the top right) labeled **Board** and **Table**. 3. Click the view format you prefer. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-change-tracker-view-mode.png) ### How can I customize the table view? When using the **Table View**: * Processes are listed as rows. * You can choose which columns (process details) to show. * Click the column settings icon (often a gear or columns icon, usually top right of the table). * Check/uncheck the columns you want to show or hide (e.g., Name, Progress, Status, Due Date, Owner, Start Date, Last Updated). ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-customize-table-view.png) This lets you adjust the Table view to show the most relevant information for your tracking needs. Customization ensures optimal workflow visibility based on your specific monitoring requirements. ## Table view navigation best practices **Known behavior**: Table view may reset to the default (first) blueprint in your dropdown list when navigating back to the tracker. **Common triggers that cause blueprint reset**: - Using the browser back button instead of in-app navigation - Navigating from external links back to tracker view - Session timeouts or forced page refreshes - Following bookmarks that don't include blueprint parameters **Best practices to maintain your selected blueprint**: 1. **Use in-app navigation** - Click the tracker menu item instead of browser back button 2. **Create specific bookmarks** - Bookmark the URL after selecting your blueprint (includes the selection in the URL) 3. **Avoid browser controls** - Use Tallyfy's navigation menu rather than browser forward/back buttons 4. **Expect reselection after refresh** - Page refreshes will return to default blueprint **Quick recovery**: When the view resets, simply reselect your desired blueprint from the dropdown. All your data remains intact - it's just the view selection that resets. Consider this a minor inconvenience rather than a data issue. - **[Organize processes](https://tallyfy.com/products/pro/tracking-and-tasks/tracker-view/organize-processes/)**: Tallyfy offers multiple organization methods including folders favorites filtering and archiving to help users efficiently manage and view their active processes for improved workflow visibility. ## Ways to organize processes Tallyfy provides ways to manage your view of active [processes](/products/pro/tracking-and-tasks/processes/) by adding them to folders, marking them as favorites, filtering your view, or archiving completed ones. These organization options enable efficient workflow management and improved process visibility. Explore the articles below to learn more. ### Organize processes - **[Organize processes into folders](https://tallyfy.com/products/pro/tracking-and-tasks/tracker-view/organize-processes/how-can-i-add-tasks-to-folders-in-tallyfy/)**: Tallyfy allows users to organize active processes into folders within the Tracker view by using a three-dot menu to add processes to existing or newly created folders which can then be filtered for better workflow visibility and project management. ## Organize active processes into folders This article explains organizing active [processes](/products/pro/tracking-and-tasks/processes/) into folders 📁 in the **[Tracker](/products/pro/tracking-and-tasks/tracker-view/)** view. Folders help sort and group processes for better tracking (e.g., by client, project, status). This organization approach enhances workflow visibility and project management efficiency. :::note[Why are process folders separate from template folders?] Tallyfy uses separate folder systems for [templates](/products/pro/documenting/templates/) and for active processes. This separation lets you organize: - Templates by type or department (e.g., "HR Templates", "Client Ops Templates"). - Active processes by client, project, or status (e.g., "Coca Cola Work Requests", "Urgent Projects"). This means an "Employee Onboarding" template might be in an "HR" template folder, but running onboarding processes could be in process folders like "Sales Onboardings" or "IT Onboardings". This dual structure provides optimal organization for different workflow phases. ::: ### How do I create or add processes to folders? Once a process is in a folder, you can filter the **Tracker** view to show only processes in that folder: ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-filter-by-folder-process.png) - **[Favorite section](https://tallyfy.com/products/pro/tracking-and-tasks/tracker-view/organize-processes/how-can-i-favorite-and-filter-processes-on-tallyfy/)**: The Favorites feature allows bookmarking processes tasks members and templates for quick access while automatically enabling notifications about specific events like step changes task completions and process launches based on the item type being watched. ## Use the Favorites section for bookmarking and watching The Favorites feature (click the star icon ⭐ in the left sidebar) lets you bookmark items (processes, tasks, members, templates) for quick access. Adding an item to Favorites also automatically "watches" it, meaning you'll receive notifications about specific events related to that item. This dual functionality combines organization with intelligent monitoring. ### What does "watching" mean? When you "watch" an item (by adding it to Favorites), Tallyfy notifies you when specific events occur. The types of events that trigger notifications depend on what you're watching - not all changes trigger notifications. ### What events trigger notifications for watched items? Different types of watched items trigger notifications for different events: #### Templates (Both Procedure and Document Templates) When you watch any template type, you'll be notified about: - **Step creation** - When new steps are added to the template - **Step deletion** - When steps are removed from the template - **Assignee changes** - When step assignees are added or removed - **Form field creation** - When new form fields are added to steps - **Form field deletion** - When form fields are removed from steps **Note**: Document templates and procedure templates trigger the same watch events. Changes to document content or descriptions don't trigger notifications. #### Tasks (Including One-Off Tasks) When you watch a task, you'll be notified about: - **Task completion** - When the task is marked as complete **What does NOT trigger notifications for watched tasks**: - Assignee changes or additions - Deadline or due date changes - Task title or description edits - Task reopening - Comments or discussions on the task - File attachments - Form field value changes These changes only create auto-comments within the task itself but don't send watcher notifications. #### Processes When you watch a process, you'll be notified about: - **Task completion** - When any task within the process is completed - **Process completion** - When the entire process is completed #### Members When you watch a team member, you'll be notified when that person: - **Launches a process** - Creates a new process instance - **Completes a task** - Finishes any task assigned to them ### How do I access my Favorites? Click the star icon ⭐ in the left sidebar to open Favorites. This shows all items you've marked. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-favorite-section.png) ### How can I favorite items? * **Processes**: Hover over a process in the Tracker view and click the star icon ⭐. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-select-star-on-process.png) * **Tasks**: Open the task and click the star icon ⭐ next to the task name. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-favorite-task.png) * **Members** (Admins Only): Go to **Settings > Organization > Members**, click a member's name, then click the star icon ⭐. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-favorite-people.png) * **Templates**: Go to the **Templates** library, hover over a template, and click the star icon ⭐. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-favorite-template.png) Clicking the star again unfavorites (and unwatches) the item. ### How do I filter my Favorites? Within the Favorites section, use the filter options at the top to show only certain item types (e.g., only show favorited processes or favorited tasks). ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-filter-favorite.png) ### How can I set notification preferences for watched items? For each item in your Favorites list, you can control how and how often you're notified about the events listed above. * **Target Options**: Choose *how* you want to be notified: * **Email** - Receive notifications via email (most common) * **Webhook** - Send notifications to external systems via webhook URLs ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-target-options-favorite.png) * **Notification Frequency**: Choose how often you're notified when events occur: * **Electric**: Get notified immediately when an event happens * **Mindful**: Events are collected and sent as a digest every 3 hours * **Chilled**: Events are collected and sent as a daily digest once per day ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-frequency-options-favorite.png) You can set different frequencies for different items, letting you get instant alerts for critical items and digest summaries for less urgent ones. The actual events that trigger notifications remain the same regardless of frequency - only the timing of when you receive the notifications changes. ### How do I manage my watched items? The Favorites section is where you manage watched items: * View your full list of favorited/watched items. * Change notification settings (frequency/target) for any item. * Filter your list. * Remove items by clicking the star again (unfavorites/unwatches). - **[Archive and unarchive processes in Tracker view](https://tallyfy.com/products/pro/tracking-and-tasks/tracker-view/organize-processes/how-to-archive-and-unarchive-processes-in-tallyfy/)**: Tallyfy allows users to archive processes to remove them from active views while preserving data and provides unarchiving options through the Tracker view's filter system with different permission levels for various user types. ## Archive and unarchive processes This article explains how to archive and unarchive [processes](/products/pro/tracking-and-tasks/processes/) in Tallyfy. Archiving removes a process from active views without permanently deleting it. This feature provides workflow organization while preserving data for future reference. :::note[How can I pause or stop processes?] Tallyfy does not currently have a feature to "pause" or "stop" a running process temporarily. If a process is started incorrectly, is no longer needed, or was just for testing, **archiving** is the recommended way to remove it from your active Tracker view. You can [delete archived processes permanently](/products/pro/tracking-and-tasks/processes/edit-processes/how-can-i-delete-a-process-in-tallyfy/) later if needed. ::: :::note[Role permissions for archiving] **Who can archive/unarchive processes:** - **Administrator users**: ✅ Full archive/unarchive permissions - **Standard users**: ✅ Full archive/unarchive permissions - **Light users**: ❌ Cannot archive or unarchive processes **Important for Light users**: The archive button will appear in the interface, but clicking it will not actually archive the process. This is an intentional permission restriction to ensure proper process management control. **Workaround for Light users**: If your organization has many Light users who complete processes that need archiving, enable auto-archive: 1. Go to **Settings** > **Organization** > **Customization** 2. Enable auto-archive for completed processes 3. Processes will automatically archive when all tasks are completed This eliminates the need for manual archiving by Light users while keeping your Tracker view clean. ::: ### How do I archive a process? To archive a process: ### How do I unarchive a process? To unarchive (restore) a process: ### Tasks view - **[Organize tasks and processes into folders](https://tallyfy.com/products/pro/tracking-and-tasks/tasks-view/how-can-i-add-tasks-to-folders-in-tallyfy/)**: Tallyfy provides two separate folder systems - one for organizing master templates in the Templates library and another for organizing active work in Tasks and Tracker views - plus flexible tags that allow items to belong to multiple categories for enhanced workflow organization. ## Organizing work with folders and tags Tallyfy has two separate folder systems plus tags for organization. ### Two folder systems Tallyfy has **two completely separate sets of folders**: 1. **Template Folders**: Used *only* in the **Templates** library section to organize your master templates. [Learn more here](/products/pro/documenting/templates/organize-templates-into-folders/). 2. **Task/Process Folders**: Used *only* in the **Tasks** and **Tracker** views to organize your *active* work (running processes and individual tasks). Templates and active work have separate folder systems because they need different organizational structures. **Example:** * **Template Folder**: `HR Templates` > `Onboarding` * **Process Folders**: `Active Onboardings - Sales Team`, `Active Onboardings - IT Team` This article focuses on **Task/Process Folders** used in the Tasks and Tracker views. ### Organizing tasks into folders Create folders in the **Tasks** view to group related tasks. #### Adding tasks to folders 1. Find the task in your **Tasks** view. 2. Click the menu icon (three dots ⋮) on the task card. 3. Select **Add to Folder**. 4. Choose an existing folder or create a new one. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-add-task-to-folder.png) #### Viewing tasks by folder 1. Go to the **Tasks** view. 2. Click **Add filter**. 3. Select **Folder** as the filter type. 4. Choose the folder you want to see tasks from. ![](https://screenshots.tallyfy.com/tallyfy/pro/desktop-light-filter-task-process.png) ### Organizing processes into folders Running processes can be organized into folders in the **Tracker** view. #### Adding processes to folders 1. Go to the **Tracker** view. 2. Find the running process card. 3. Click the menu icon (three dots ⋮) on the process card. 4. Select **Add to Folder**. 5. Choose an existing folder or create a new one. #### Viewing processes by folder 1. Go to the **Tracker** view. 2. Click **Add Filter**. 3. Select **Folder** as the filter type. 4. Choose the folder you want to see processes from. ### Using tags In addition to folders, you can use [Tags](/products/pro/documenting/templates/how-to-manage-templates-and-processes-with-tags/) (flexible labels) to organize both tasks and processes. * **Tagging Tasks**: Open the task, click the menu (⋮), select **Add Tags**. * **Tagging Processes**: Open the process, click the menu (⋮), select **Add Tags**. * **Filtering by Tag**: Use the **Tag** filter option in both the **Tasks** and **Tracker** views. Tags let items belong to multiple categories (a task could be tagged "Urgent" and "Client A"), while folders provide a single location. - **[Customize the task view](https://tallyfy.com/products/pro/tracking-and-tasks/tasks-view/how-can-i-customize-task-views-in-tallyfy/)**: Tallyfy's Tasks View allows users to filter tasks by status assignee state tags templates processes folders and date ranges while offering sorting options by most delayed or most recent activity to efficiently organize and locate specific work items. ## Filters and sorting in the tasks view The Tallyfy **[Tasks View](/products/pro/tracking-and-tasks/tasks-view/)** shows all your [tasks](/products/pro/tracking-and-tasks/tasks/) in one place. You can filter and sort this list to find exactly what you need - whether that's overdue tasks, work assigned to a specific person, or items from a particular template. It's straightforward. ### How do I add filters to the tasks view? Click the **Add Filter** button at the top of the Tasks view. Simple as that. You can stack multiple filters - they work together to narrow down your list. Here's what you can filter by: * **Status**: See just your 'To Do' tasks (that's the default) or switch to 'Completed' ones * **Assignee**: Find tasks for specific [members](/products/pro/documenting/members/), [guests](/products/pro/documenting/guests/) (by email), or spot unassigned work with 'Nobody Assigned' * **Task State**: Zero in on what's 'Overdue', 'Due Soon', or still 'On time' * **Tag**: Pull up tasks with specific tags - great if you tag by project or priority * **Template**: Show only tasks from a particular [template](/products/pro/documenting/templates/) * **Process Name**: Find tasks within a specific [process](/products/pro/tracking-and-tasks/processes/) by name * **Folder**: View tasks you've tucked into a [folder](/products/pro/tracking-and-tasks/tasks-view/how-can-i-add-tasks-to-folders-in-tallyfy/) * **Date Range**: Filter by due date or creation date - perfect for weekly planning ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-filter-task.png) ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-add-filter-to-task.png) #### Example: Want to see what you've already finished? #### Example: Finding tasks that need an owner #### Example: Checking a guest's workload ### How can I sort tasks in the tasks view? Look for the dropdown in the top right corner of your Tasks view. You've got two sorting options: * **Most Delayed** - puts your overdue tasks right at the top (where they probably need to be) * **Most Recent** - shows tasks with fresh activity first ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-sort-tasks.png) Mix filters and sorting together, and you'll find what you need in seconds. Filter by assignee, sort by most delayed - instantly see who's falling behind. Filter by template, sort by most recent - track the latest activity on specific workflows. The combinations are endless. ### Tutorials - **[Franchise operations guide](https://tallyfy.com/products/pro/tutorials/franchise-operations/)**: Tallyfy enables franchise systems to transform static SOPs into active workflows that franchisees actually execute with real task assignments and completion tracking across hundreds of locations while offering two deployment models - distributed purchasing where each franchisee owns their account for autonomy and privacy or centralized purchasing for unified management - with template sharing via API and built-in features like automated task assignment and performance tracking that typically improve margins through reduced training time and fewer errors. ## Using Tallyfy for franchise business models ![Franchise operations visualized as a central headquarters building on the left connected by flowing green lines to multiple identical storefronts on the right - each with local customization indicators while maintaining brand consistency](https://screenshots.tallyfy.com/illustrations/franchise-operations.jpeg) Franchise operations need standardized processes that work across hundreds of locations while letting each franchisee adapt to local needs. Tallyfy transforms scattered SOPs - whether they're PDFs, spreadsheets, or paper binders - into living workflows that franchisees actually run, not just read. Here's the critical difference: Your franchisees don't just view procedures. They launch them as active [processes](/products/pro/tracking-and-tasks/processes/) with real [task assignments](/products/pro/tracking-and-tasks/tasks/), automated reminders, and completion tracking. A swim school with 200 locations can ensure every franchise follows the same pool cleaning protocol while tracking that it actually happened. ## Two franchise deployment models ### Model 1: Distributed purchasing (recommended) Each franchisee purchases their own Tallyfy account directly. This gives them: - Full control over their templates and customization - Independent billing and user management - Ability to edit HQ-provided templates for local needs - Private, secure workspace (not visible to other franchisees) **Why this matters**: Templates in free accounts become public - visible to anyone on the internet. Your proprietary franchise processes need the security of paid accounts[^1]. ### Model 2: Centralized purchasing HQ purchases and manages all franchisee accounts as one large organization. This provides: - Single billing relationship - Centralized user management - Direct template distribution - Unified reporting across all locations Most franchises choose distributed purchasing because franchisees want autonomy over their operations and billing. ## Setting up your franchise system ### For franchise headquarters ### For franchisees ## Template sharing between organizations Currently, direct template copying between Tallyfy organizations requires an API-based approach. Here's how franchise systems handle this: **Current method**: 1. HQ exports templates using the [API](/products/pro/integrations/open-api/) 2. HQ shares template data with franchisees (JSON format) 3. Franchisees import or recreate templates in their accounts 4. Each franchisee customizes for their specific needs **Coming soon**: Direct template sharing between organizations is on the product roadmap, which will simplify this process significantly. :::tip[Workaround for easier sharing] Create a shared document library with step-by-step template documentation that franchisees can use with Tallyfy's [import feature](/products/pro/documenting/templates/import-feature/) to quickly rebuild templates. ::: ## Why franchisees need paid accounts Free Tallyfy accounts make all templates publicly searchable - anyone could find and view your proprietary franchise processes. Paid accounts ensure: - **Privacy**: Your competitive advantage stays confidential - **Security**: Only authorized users access your workflows - **Customization**: Full editing capabilities for local adaptation - **Support**: Direct access to Tallyfy's support team - **Capacity**: No limits on active processes or team members Think of it this way: Would you want competitors seeing exactly how you onboard customers or train staff? That's why each franchisee needs their own secure, paid workspace. ## Beyond documentation - running live processes Traditional franchise manuals sit on shelves. Tallyfy templates become active workflows where: - **Tasks auto-assign** to the right person based on [job titles](/products/pro/documenting/templates/edit-templates/understanding-assignment-types/) - **AI automation** handles routine steps without human intervention - **Deadlines track** automatically with escalation for overdue items - **Forms collect** data consistently across all locations - **Reports show** exactly which locations complete which processes A restaurant franchise can track that every location completed their daily opening checklist. A fitness franchise knows which clubs performed equipment maintenance on schedule. The difference between reading an SOP and running it through Tallyfy directly impacts your margins - significantly reducing process time while ensuring consistency. ## Free SSO for all franchise accounts Whether you choose centralized or distributed purchasing, [Single Sign-On (SSO)](/products/pro/integrations/authentication/) comes free with every Tallyfy account. This means: - HQ can use corporate identity providers (Azure AD, Okta, etc.) - Each franchisee can set up their own SSO independently - No additional SSO charges regardless of organization size - Simplified access management across locations ## Measuring franchise performance With Tallyfy, franchise operations gain visibility into: - Which locations consistently follow procedures - Process completion times across different franchises - Common bottlenecks or failure points - Compliance rates for critical workflows - Training effectiveness for new franchisees The optional [Tallyfy Analytics](/products/pro/integrations/analytics/) add-on provides deeper insights with custom dashboards comparing performance across your entire franchise network. ## Margin improvement through automation Franchisees typically see margin improvements through: 1. **Reduced training time**: New employees follow guided workflows instead of shadowing for weeks 2. **Fewer errors**: Checklists and validations prevent costly mistakes 3. **Automated coordination**: Tasks flow between team members without manual handoffs 4. **Consistent quality**: Every customer gets the same excellent experience 5. **Time savings**: Manual processes complete significantly faster with automation Consider a home services franchise: Instead of calling to schedule follow-ups, [automations](/products/pro/documenting/templates/automations/) trigger based on job completion. Service techs focus on service, not administration. ## Getting started with franchise operations ### Quick pilot program Start with 3-5 franchisees to: 1. Validate your template design 2. Gather feedback on customization needs 3. Measure actual time and cost savings 4. Build success stories for system-wide rollout ### Support resources - **For HQ**: Work with Tallyfy's team to design your template distribution strategy - **For franchisees**: Each account includes onboarding support and training resources - **Ongoing help**: Access our [support team](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/) for technical questions ### Investment and pricing View current pricing at https://tallyfy.com/pricing/. Consider: - Full Members (template creators) vs Light Members (task executors) - Annual subscriptions save approximately 16% - Volume discussions available for 50+ franchise locations - Each franchisee's investment typically pays back within 60-90 days through efficiency gains [^1]: Paid accounts ensure all templates and processes remain private to your organization only - **[Create an organization](https://tallyfy.com/products/pro/tutorials/how-can-i-create-a-new-tallyfy-account/)**: Tallyfy workflow management requires users to create an account by signing up at their website using personal details or existing Microsoft/Google accounts then setting up an organization workspace with potential IT administrator approval needed for Microsoft sign-ins and centralized login management allowing easy switching between multiple organizations. ## Signing up for Tallyfy and creating your organization To start using Tallyfy workflow management, you first create a user account. This account lets you create your company's workspace (an organization) or join one that already exists. Learn more [about Tallyfy](/products/pro/miscellaneous/about-tallyfy/) and why thousands of companies trust us with their workflows. When you create a brand new organization, Tallyfy usually assigns you a helpful welcome [task](/products/pro/tracking-and-tasks/tasks/) to guide you through the basics. You can ask questions by commenting on this task, or book a free call with support via [https://tallyfy.com/booking/](https://tallyfy.com/booking/). ### Microsoft sign-in requiring admin approval If you're trying to sign up or sign in with Microsoft and see "Need admin approval" - this happens when your organization has restricted which apps employees can access. The error means Tallyfy needs permission from your IT administrator before you can use it. **For users seeing this error:** 1. Take a screenshot of the "Need admin approval" message 2. Send it to your IT administrator or help desk 3. Ask them to approve the "Tallyfy API" application in Azure Active Directory 4. As an alternative, create your account using email and password instead of Microsoft sign-in **For IT administrators:** To approve Tallyfy for your organization: 1. Sign in to the [Azure Portal](https://portal.azure.com) as an administrator 2. Navigate to **Azure Active Directory** → **Enterprise applications** 3. Search for "Tallyfy API" in pending requests or consent requests 4. Review and approve the application for your organization 5. Grant the requested permissions (basic profile and email access) After approval, users in your organization can sign in with their Microsoft accounts. The approval only needs to happen once for your entire organization. For more details about this Azure AD consent requirement, see [Microsoft's documentation on admin approval](https://learn.microsoft.com/en-us/answers/questions/1497998/need-admin-approval-popup). Your Tallyfy login (email and password) is managed through a central system ([account.tallyfy.com](https://account.tallyfy.com)), which handles sign-ins and password resets for all Tallyfy products. If your email address is later invited to join other Tallyfy organizations (e.g., a client's or partner's), you can easily [switch between them](/products/pro/settings/personal-settings/how-can-i-switch-between-organizations-in-tallyfy/) using the same login. :::tip[Stuck in authentication loops?] If you're redirected repeatedly or can't complete account creation, visit [https://account.tallyfy.com/logout](https://account.tallyfy.com/logout) to clear all sessions, then try again. This fixes most authentication issues. ::: - **[Create an automation](https://tallyfy.com/products/pro/tutorials/how-can-tallyfy-automate-and-streamline-my-processes/)**: Tallyfy automation rules use IF-THEN conditional logic to intelligently adapt workflows based on user inputs task completions and other triggers eliminating manual adjustments while automatically showing relevant steps assigning tasks and responding to changing circumstances throughout your processes. ## Automating and streamlining processes This practical tutorial demonstrates creating intelligent [automation](/products/pro/documenting/templates/automations/) rules in Tallyfy that dynamically adapt workflows based on specific conditions and user inputs. Tallyfy automation rules eliminate manual workflow adjustments while ensuring processes automatically respond to changing circumstances. This reduces administrative overhead and improves operational efficiency across your organization. ### Basic automation concepts Tallyfy automation rules operate through "if-this-then-that" conditional logic that responds intelligently to workflow events: * **IF** specific events occur (the *Condition*), such as task completions, particular form field values, or approval decisions... * **THEN** Tallyfy automatically executes defined actions (the *Action*), including revealing hidden steps, reassigning tasks, or modifying deadlines Automation rules can be created based on various conditions including task completion, form field answers, and approval decisions from Approve/Reject steps. **Example scenario:** In an Employee Onboarding process, you want to display different steps based on whether the new hire is a "Field worker" or an "Office worker". ### Setting up form field automation for onboarding Follow these steps to configure the automation for the example scenario: :::note[Use clear automation names] Always give your [automation](/products/pro/documenting/templates/automations/) rules descriptive names (like in the examples: "Show Field Training if Role is Field Worker"). Avoid generic names like "Rule 1" or "Field Check". Clear names make it much easier for you and others to understand the purpose of each rule later without needing to examine its conditions and actions. ::: What happens when the process launches: * Only Step 1 appears as assigned and visible initially. * After the employee selects their role in Step 1, the relevant step (either 2 or 3) becomes assigned and visible. The designated assignees receive automatic notifications. * Assignees can click the [task](/products/pro/tracking-and-tasks/tasks/) link in their email notification to complete their assigned step. - **[Welcome snippets](https://tallyfy.com/products/pro/tutorials/how-to-create-a-custom-onboarding-snippet/)**: Tallyfy allows organizations to create custom onboarding snippets through Settings > Organization > Personalization where you can configure either one-time welcome messages that appear only when new members first log in or persistent homepage messages that always display to all members by first creating the snippet content and then assigning it to the appropriate display option. ## How can I create a custom onboarding snippet in Tallyfy? Tallyfy [Snippets](/products/pro/documenting/templates/snippets/) enable organizations to create personalized welcome messages and instructional content for new team members. This feature streamlines the onboarding process and ensures consistent information delivery. These customizable Tallyfy snippets enhance the onboarding experience by providing immediate access to essential information, training resources, and organizational guidelines during critical initial interactions with the platform. Strategic snippet placement improves user adoption and reduces initial confusion. These special snippets can be configured in **Settings > Organization > Personalization** under two distinct options: * **MEMBERS - JUST JOINED**: This snippet appears **only the first time** a new [member](/products/pro/documenting/members/) logs in after accepting their invite. This option is ideal for one-time welcome messages, links to training videos, or key onboarding documents that require immediate attention. * **MEMBERS - HOMEPAGE**: This snippet **always shows** on the Tallyfy homepage for *all* members in your organization. Use this persistent display for ongoing important announcements, links to company resources, or support information that requires continuous visibility. ### How do I set up a welcome snippet? Now, the chosen snippet will appear in the specified location for your members, providing immediate guidance and essential information during their platform experience. - **[Workflow applications](https://tallyfy.com/products/pro/tutorials/industry-specific-workflow-applications/)**: Tallyfy addresses industry-specific workflow requirements through flexible template systems and conditional logic that enable organizations across financial services healthcare manufacturing and other regulated sectors to create compliant processes with comprehensive audit trails meeting strict regulatory demands from FDA and HIPAA to FINRA and ISO standards. ## How does Tallyfy address industry-specific workflow requirements? Important note - this article is not legal advice of any kind. You need to do your own research and use this content at your own risk. Different industries have unique operational challenges, regulatory requirements, and process complexities. Tallyfy's flexible workflow template system and conditional logic capabilities enable organizations to create workflows that address these industry-specific needs while maintaining consistency and compliance. Rather than forcing generic processes, Tallyfy adapts to the specialized requirements of each sector through configurable automations, conditional branching, industry-aware AI template generation, and complete audit trail capabilities that meet the strictest regulatory demands. ## What financial services workflows does Tallyfy support? ### Banking and Credit Unions Financial institutions face complex regulatory requirements and need precise process execution: **Employee Onboarding with Compliance Requirements**: - **FINRA compliance steps**: Automated routing for securities licensing verification - **Role-based conditional logic**: Different onboarding paths for tellers, commercial lending, IT, and management roles - **Branch-specific procedures**: Location-based automations for multi-branch operations - **BSA training tracking**: Systematic completion verification for regulatory audits **Marketing Approval Workflows**: - **Regulatory compliance checkpoints**: All marketing materials require compliance officer approval before publication - **Interest rate verification**: Automated checks to ensure advertised rates match current offerings - **Multi-stage approvals**: Commercial aspects, legal review, and final authorization sequences - **Audit trail maintenance**: Complete documentation for regulatory examinations **Account Creation and Management**: - **Standardized procedures**: Consistent account setup across different personnel - **KYC (Know Your Customer) integration**: Systematic identity verification workflows - **AML (Anti-Money Laundering) compliance**: Built-in checks and documentation requirements - **Cross-training capabilities**: Multiple staff can perform critical functions using documented procedures. For multinational operations, consider [global language requirements](/products/pro/integrations/azure-translation/global-workplace-language-requirements/) to ensure all staff can understand critical procedures ### Insurance companies Insurance workflows often involve complex decision trees and carrier-specific requirements: **Marine Insurance Endorsement Processing**: - **Carrier-specific procedures**: Different workflows for different insurance carriers - **Equipment vs. vessel endorsements**: Conditional logic determines appropriate documentation requirements - **Progressive information gathering**: Initial assessment followed by detailed data collection as needed - **Tribal knowledge preservation**: Expert knowledge captured in systematic, repeatable procedures **Claims Processing and Risk Assessment**: - **Conditional routing based on claim type**: Different procedures for equipment damage vs. vessel incidents - **Documentation requirements**: Systematic collection of required evidence and reports - **Approval hierarchies**: Risk-based routing to appropriate decision makers - **Compliance with carrier requirements**: Automated adherence to specific carrier protocols ### Asset management firms Asset management companies face extensive regulatory audit trail requirements across multiple jurisdictions: **Investment Adviser Compliance (SEC Rules 204-2 and 206(4)-7)**: - **Books and records maintenance**: Every advisory transaction logged with user identity, timestamp, and decision rationale for five-year retention periods [1] - **Annual compliance review documentation**: Written documentation of each compliance program review, capturing reviewer identity, findings, and remediation actions [2] - **Order management audit trails**: Complete lifecycle tracking from order inception through execution, meeting FINRA Rules 7160 and 7360 requirements [3, 4] **Private Fund Management (Enhanced SEC Rules)**: - **Portfolio valuation procedures**: Step-by-step workflows capturing valuation methodologies, responsible parties, and approval chains - **Fee calculation documentation**: Detailed trails showing fee computation logic, supporting data, and authorizing personnel - **Investor reporting workflows**: Systematic processes ensuring accurate, timely disclosures with complete audit trails **European MiFID II/MiFIR Compliance**: - **Transaction reporting workflows**: Robust audit trail systems reconstructing complete order lifecycles for regulatory reporting [5] - **Communications retention**: Electronic records of all client-related communications maintained for five to seven years with user attribution and timestamps [6] - **Best execution documentation**: Systematic procedures demonstrating compliance with best execution obligations **Anti-Money Laundering (AML) Processes**: - **Customer due diligence workflows**: Risk-based KYC procedures with detailed documentation of review steps and responsible personnel - **Suspicious activity monitoring**: Alert investigation workflows capturing analyst findings, escalation decisions, and SAR filing rationale [7] - **AML program documentation**: Complete procedures meeting current and forthcoming FinCEN requirements ## What industries require mandatory audit trail compliance? Numerous highly regulated sectors legally mandate workflow processes that generate immutable audit trails, logging each task with user identity, timestamp, and outcome to satisfy safety, quality, and regulatory requirements. ### Pharmaceutical manufacturing **FDA Electronic Batch Manufacturing Records (eBMR)**: Pharmaceutical companies must implement secure, computer-generated audit trail systems capturing every creation, modification, or deletion of critical production data under 21 CFR 211.188(b) [8]. - **Production step documentation**: Each weighing, mixing, and cleaning operation logged with operator identity and timestamp - **Review requirement workflows**: Systematic procedures ensuring audit trail review after each significant manufacturing step - **Change control processes**: All modifications documented with user ID, timestamp, and scientific rationale - **Deviation investigation**: Standardized workflows for investigating and documenting any deviations from approved procedures ### Clinical research and trials **ICH E6(R3) Good Clinical Practice Requirements**: Clinical trial sponsors must maintain computerized systems capturing metadata that reconstructs the complete course of trial events [9]. - **Electronic Case Report Form (eCRF) workflows**: Every data entry and modification logged with investigator identity, timestamp, and reason for change - **Protocol deviation documentation**: Systematic procedures for documenting, investigating, and reporting any deviations from approved protocols - **Audit trail reviews**: Risk-based workflows for periodic review of trial data and metadata integrity - **Regulatory submission processes**: Comprehensive documentation supporting regulatory filings with complete user attribution ### Medical device manufacturing **ISO 13485 Quality Management System Requirements**: Medical device manufacturers must maintain robust document control and traceability systems ensuring every change is logged with responsible individual and rationale [10]. - **Design control workflows**: Systematic procedures capturing design inputs, outputs, reviews, and changes with complete user attribution - **Production record maintenance**: Batch-specific documentation showing which personnel performed each manufacturing step - **Corrective and preventive action (CAPA) processes**: Full workflows documenting problem identification, investigation, and resolution - **Management review procedures**: Regular quality system reviews with documented findings and improvement actions ### Aviation maintenance **FAA Advisory Circular AC 145-9A Requirements**: Aviation repair stations must use maintenance work packages capturing detailed records of every maintenance action [11]. - **Maintenance task documentation**: "Travelers" or "routers" listing each step with technician signature, stamp, or electronic ID - **Inspection workflows**: Systematic procedures ensuring proper inspection and sign-off for each maintenance task - **Parts traceability**: Complete documentation of parts installation with serial numbers and responsible personnel - **Return-to-service processes**: Final inspection and approval workflows with clear accountability chains ### Nuclear power operations **10 CFR 50 Appendix B Quality Assurance Requirements**: Nuclear facilities must maintain QA records detailing each inspection, test, and corrective action with clear personnel attribution [12]. - **Quality assurance documentation**: Comprehensive workflows capturing inspection findings, test results, and corrective actions - **Fitness-for-duty procedures**: Systematic processes documenting personnel qualification determinations with 40-year retention requirements - **Configuration management**: Change control processes ensuring all modifications are properly documented and approved - **Emergency response procedures**: Pre-planned workflows with clear role assignments and communication protocols ### Food manufacturing and safety **FDA Food Safety Modernization Act (FSMA) Requirements**: Food facilities must document every monitoring activity, verification check, and corrective action under 21 CFR Part 117 [13]. - **Hazard Analysis and Critical Control Points (HACCP) documentation**: Systematic procedures capturing monitoring data, verification activities, and corrective actions - **Preventive controls verification**: Regular workflows confirming the effectiveness of implemented controls - **Supplier verification programs**: Thorough procedures for evaluating and monitoring supplier compliance - **Recall procedures**: Pre-established workflows enabling rapid product recall with complete traceability ### Healthcare IT systems **HIPAA Audit Controls Requirements**: Healthcare organizations must implement thorough audit trail systems under 45 C.F.R. § 164.312(b) capturing all electronic protected health information (ePHI) interactions [14]. - **Access logging workflows**: Systematic documentation of user log-on/off events, file access attempts, and record modifications - **Breach investigation procedures**: Standardized workflows for investigating and documenting potential privacy breaches - **Risk assessment processes**: Regular procedures for evaluating and documenting security risks - **Incident response workflows**: Detailed procedures for responding to security incidents with thorough documentation requirements ### Oil and Gas Operations **Daily Drilling Report (DDR) Requirements**: Upstream operations require complete documentation of all drilling activities with chronological records and personnel attribution [15]. - **Drilling activity documentation**: Time-based logging of drilling operations, bit runs, mud logging, and casing operations - **Non-productive time tracking**: Detailed documentation of delays, equipment failures, and remediation actions - **Safety incident reporting**: Systematic procedures for documenting and investigating safety events - **Environmental compliance workflows**: Regular procedures ensuring adherence to environmental regulations ### Automotive manufacturing **IATF 16949:2016 Traceability Requirements**: Automotive manufacturers must implement unique identification and logging systems for every production process step [16]. - **Production traceability workflows**: Each manufacturing operation logged with operator identity, timestamp, workstation, and quality parameters - **Change control procedures**: Systematic documentation of all process changes with technical justification - **Supplier quality management**: Comprehensive workflows for monitoring and documenting supplier performance - **Customer complaint resolution**: Standardized procedures for investigating and resolving quality issues ### Chemical process safety management **OSHA 29 CFR 1910.119 Process Safety Management Requirements**: Facilities handling highly hazardous chemicals must maintain detailed training and safety review records [17]. - **Training documentation workflows**: Detailed procedures capturing employee training with identity, date, and verification methods - **Pre-startup safety reviews**: Systematic procedures documenting safety checks before process modifications - **Process hazard analysis**: Regular workflows for identifying and documenting process hazards - **Incident investigation procedures**: Standardized processes for investigating and documenting safety incidents ### Mining operations **MSHA Workplace Examination Requirements**: Mining operations must conduct regular workplace examinations with detailed documentation under 30 CFR 56/57.18002 [18]. - **Shift examination procedures**: Visual inspection workflows with documentation of tracks traversed and hazards identified - **Equipment inspection processes**: Systematic procedures for documenting equipment condition and safety compliance - **Hazard abatement workflows**: Standardized processes for identifying, documenting, and correcting safety hazards - **Training record maintenance**: Complete documentation of miner safety training and certification ### Utilities and Infrastructure **NERC CIP Cybersecurity Requirements**: Electric utilities must implement thorough audit logging systems under NERC CIP-007-6 and CIP-010-5 [19]. - **Security event monitoring**: Systematic documentation of user activities on critical cyber systems - **Patch management workflows**: Detailed procedures documenting security patch deployment with personnel attribution - **Access control procedures**: Full workflows managing and documenting system access - **Incident response processes**: Standardized procedures for responding to cybersecurity incidents ### Forensic and Calibration Laboratories **ISO/IEC 17025:2017 Requirements**: Testing and calibration laboratories must maintain complete audit trails under Clause 7.5.3 [20]. - **Electronic record-keeping workflows**: Systems preventing overwriting of original entries while maintaining complete audit trails - **Sampling documentation procedures**: Systematic processes capturing sampler identity, location, environmental conditions, and statistical rationale - **Calibration workflows**: Complete procedures documenting calibration activities with personnel attribution - **Quality control processes**: Regular procedures ensuring measurement quality and traceability ### Transportation and Railroad **49 CFR 213 Track Inspection Requirements**: Railroad operators must conduct regular track inspections with detailed documentation requirements [21]. - **Visual inspection workflows**: Systematic procedures documenting track conditions with inspector identity and findings - **Defect remediation processes**: Standardized workflows for addressing identified track defects - **Equipment inspection procedures**: Regular documentation of track maintenance equipment condition - **Training and certification workflows**: Thorough procedures ensuring inspector qualifications ### Construction and Equipment Safety **OSHA 29 CFR 1926.1412 Crane Inspection Requirements**: Construction operations must maintain detailed equipment inspection records [22]. - **Daily equipment inspection workflows**: Systematic procedures documenting equipment condition with inspector attribution - **Maintenance documentation processes**: Detailed procedures capturing equipment maintenance activities - **Safety incident reporting**: Standardized workflows for documenting and investigating construction safety events - **Training record maintenance**: Systematic procedures ensuring operator qualification and certification ## How does Tallyfy serve professional services industries? ### Legal services Law firms require precise procedures with client-specific variations: **Client Onboarding and Matter Management**: - **Practice area-specific workflows**: Different procedures for litigation, corporate, real estate, etc. - **Client ID and matter tracking**: Systematic case identification and progress monitoring - **Document preparation workflows**: Standardized processes for common legal documents - **Billing and time tracking integration**: Consistent procedures for fee management **Document Production and Review**: - **Financial affidavit preparation**: Step-by-step guidance for complex financial disclosures - **Conditional logic for asset types**: Different procedures based on real estate, investments, business ownership - **Real estate-specific steps**: Automated workflows for property valuation and debt verification - **Review and approval sequences**: Multi-stage quality control and attorney review **Regulatory Compliance Procedures**: - **Court filing requirements**: Systematic adherence to jurisdiction-specific rules - **Client confidentiality protocols**: Built-in safeguards for sensitive information handling - **Ethical compliance workflows**: Automated checks for conflict of interest and professional responsibility ### Cybersecurity and Vendor Management Technology and security firms need systematic assessment and compliance procedures: **Annual Vendor Security Assessments**: - **SOC 2 report evaluation**: Standardized review procedures for security compliance - **Custom security questionnaires**: Conditional logic based on vendor risk classification - **Multi-vendor comparison workflows**: Systematic evaluation across multiple providers - **Risk scoring and decision matrices**: Consistent assessment criteria and documentation **Security Incident Response**: - **Incident classification workflows**: Different procedures based on severity and type - **Stakeholder notification sequences**: Automated alerts to appropriate parties - **Documentation and reporting requirements**: Systematic evidence collection and reporting - **Post-incident review procedures**: Standardized analysis and improvement identification ## What healthcare and regulated industry applications exist? ### Healthcare operations Healthcare organizations require precise procedures with patient safety focus: **Patient Care Protocols**: - **Treatment pathway workflows**: Standardized care sequences for common conditions - **Medication administration procedures**: Step-by-step safety checks and documentation - **Discharge planning processes**: Systematic preparation for patient transitions - **Quality assurance protocols**: Consistent review and improvement procedures **Regulatory Compliance Management**: - **HIPAA compliance workflows**: Systematic privacy and security procedures - **Joint Commission preparation**: Standardized processes for accreditation readiness - **Incident reporting procedures**: Consistent documentation and analysis workflows - **Staff credentialing processes**: Systematic verification and maintenance procedures ### Manufacturing and Quality Control Manufacturing operations require precise, repeatable procedures: **Equipment Maintenance Protocols**: - **Preventive maintenance schedules**: Automated workflows based on equipment type and usage - **Safety procedure compliance**: Step-by-step adherence to safety requirements - **Documentation and certification tracking**: Systematic record keeping for audits - **Cross-training and knowledge transfer**: Standardized procedures for skill development ## How does Tallyfy handle industry-specific conditional logic? ### Complex decision trees Many industries require sophisticated branching based on multiple criteria: **Progressive Information Revelation**: - **Kickoff forms with essential data only**: Initial process launch with guaranteed available information - **Conditional step revelation**: Additional steps appear based on earlier responses - **Just-in-time information gathering**: Data collection precisely when needed rather than upfront - **Exception handling**: Clear procedures for unusual situations not covered in standard flows **Role-Based Process Variations**: - **Department-specific routing**: Different procedures based on organizational structure - **Expertise-level adaptations**: Simplified procedures for new staff, advanced options for experts - **Geographic or location-based variations**: Different procedures for different offices or regions, including compliance with [local language requirements](/products/pro/integrations/azure-translation/global-workplace-language-requirements/) for workforce documentation - **Client or customer-type specific workflows**: Customized procedures based on relationship type ### Regulatory and Compliance Automation Industries with heavy regulatory requirements benefit from automated compliance features: **Audit Trail Generation**: - **Complete process documentation**: Every step tracked with timestamps and responsible parties - **Export capabilities for auditors**: Easy generation of compliance reports and evidence - **Process version control**: Historical tracking of procedure changes and rationale - **Evidence collection workflows**: Systematic gathering and organization of required documentation **Risk Management Integration**: - **Risk-based routing**: Higher-risk scenarios automatically escalated to appropriate authority levels - **Compliance checkpoint enforcement**: Required approvals and verifications built into workflows - **Exception reporting**: Automatic flagging of deviations from standard procedures - **Continuous monitoring**: Real-time visibility into compliance status across all processes ## What implementation strategies work best for industry-specific requirements? ### Phased deployment approach Most industries benefit from systematic implementation: **Phase 1: High-Impact, Lower-Complexity Processes** - Start with frequently performed procedures that don't require extensive regulatory review - Focus on processes where consistency directly impacts quality or efficiency - Choose workflows that demonstrate clear value to gain organizational buy-in **Phase 2: Regulatory and Compliance-Critical Procedures** - Implement workflows that directly impact regulatory compliance or audit readiness - Include processes where standardization reduces risk or improves quality - Focus on procedures that require extensive documentation or approval trails **Phase 3: Complex, Multi-Department Workflows** - Implement processes that span multiple departments or require extensive coordination - Include workflows with complex conditional logic or numerous exception paths - Focus on procedures that benefit most from real-time tracking and visibility ### Industry expertise integration Successful implementations leverage existing industry knowledge: **Subject Matter Expert Collaboration**: - Work with internal experts to capture nuanced industry requirements - Document not just procedures but reasoning and context behind decisions - Include regulatory knowledge and compliance requirements in workflow design - Plan for ongoing expert review and procedure refinement **Regulatory and Standards Alignment**: - Ensure workflows comply with industry-specific regulations and standards - Include required documentation and approval steps for compliance purposes - Design audit-ready processes with built-in evidence collection and reporting - Plan for regulatory change management and procedure updates By understanding and addressing industry-specific requirements, Tallyfy enables organizations to maintain competitive advantages through superior process execution while ensuring compliance and quality standards are consistently met across all regulatory frameworks. ## Citations [1]: Cornell Law School. "17 CFR § 275.204-2 - Books and records to be maintained by investment advisers." Available at: https://www.law.cornell.edu/cfr/text/17/275.204-2 [2]: Cornell Law School. "17 CFR § 275.206(4)-7 - Compliance procedures and practices." Available at: https://www.law.cornell.edu/cfr/text/17/275.206%284%29-7 [3]: FINRA. "7160. Audit Trail Requirements." Available at: https://www.finra.org/rules-guidance/rulebooks/finra-rules/7160 [4]: FINRA. "7360. Audit Trail Requirements." Available at: https://www.finra.org/rules-guidance/rulebooks/finra-rules/7360 [5]: RBC Capital Markets. "Transaction Reporting Under MiFID II." Available at: https://www.rbccm.com/assets/rbccm/docs/news/2017/mifid-4of4.pdf [6]: ACA Group. "MiFID II for Asset Managers: Communications Record Keeping." Available at: https://www.acaglobal.com/insights/mifid-ii-asset-managers-communications-record-keeping/ [7]: iCapital. "FinCEN's New AML Rules: What Advisers Need to Know." Available at: https://icapital.com/insights/practice-management/fincens-new-aml-rules-what-advisers-need-to-know/ [8]: FDA. "Data Integrity and Compliance With Drug CGMP." Available at: https://www.fda.gov/media/119267/download [9]: ICH. "Good Clinical Practice (GCP) E6(R3) Draft Guideline." Available at: https://database.ich.org/sites/default/files/ICH_E6%28R3%29_DraftGuideline_2023_0519.pdf [10]: BPRHub. "ISO 13485: Traceability & Identification Requirements." Available at: https://www.bprhub.com/blogs/iso-13485-traceability-medical-device-identification [11]: FAA. "AC 145-9A - Advisory Circular." Available at: https://www.faa.gov/documentLibrary/media/Advisory_Circular/AC_145-9A.pdf [12]: NRC. "Section 15- Quality Assurance Records." Available at: https://www.nrc.gov/docs/ML0605/ML060590368.pdf [13]: Sustainable Agriculture Research & Education. "Food Safety Plan and Recordkeeping - Preventive Controls." Available at: https://sustainableagriculture.net/fsma/learn-about-the-issues/food-safety-plan-and-recordkeeping-preventive-controls/ [14]: Compliancy Group. "What Are HIPAA Audit Trail and Audit Log Requirements?" Available at: https://compliancy-group.com/hipaa-audit-log-requirements/ [15]: TID Journal. "Daily Drilling Report - Drilling & Well Completion." Available at: https://www.tidjma.tn/en/glossary/o-g-daily-drilling-report-6580/ [16]: Pretesh Biswas. "IATF 16949:2016 Clause 8.5.2.1 Identification and traceability." Available at: https://preteshbiswas.com/2023/08/01/iatf-169492016-clause-8-5-2-1-identification-and-traceability/ [17]: OSHA. "Process safety management of highly hazardous chemicals." Available at: https://www.osha.gov/laws-regs/regulations/standardnumber/1910/1910.119 [18]: Cornell Law School. "30 CFR § 56.18002 - Examination of working places." Available at: https://www.law.cornell.edu/cfr/text/30/56.18002 [19]: NERC. "Standard Development Timeline - CIP-007-X." Available at: https://www.nerc.com/pa/Stand/Project_202303_INSM_DL/2023%2003%20CIP-007-X%20redline%20to%20CIP-007-6_Dec14_2023.pdf [20]: Demarche. "Understanding and Implementing ISO/IEC 17025." Available at: https://www.demarcheiso17025.com/document/Understanding%20and%20Implementing%20ISO17025.pdf [21]: Cornell Law School. "49 CFR § 213.241 - Inspection records." Available at: https://www.law.cornell.edu/cfr/text/49/213.241 [22]: OSHA. "1926.1412 - Inspections." Available at: https://www.osha.gov/laws-regs/regulations/standardnumber/1926/1926.1412 - **[Knowledge-only mode](https://tallyfy.com/products/pro/tutorials/knowledge-only-mode/)**: Tallyfy transforms workflows into searchable living knowledge bases through knowledge-only mode that provides instant access to current procedures without formal tracking while enabling continuous improvement through comments embedded templates and AI-powered search capabilities. ## Using Tallyfy for knowledge management and documentation Tallyfy excels at running trackable workflows - but it's equally powerful as a living knowledge base. Knowledge-only mode lets you publish procedures as reference materials that teams can access without launching formal processes. Think of it this way: not every procedure needs tracking. Your team needs quick access to how-to guides that they can reference while working - like entering a sales order or handling customer calls. Knowledge-only mode delivers exactly that. ### When to use knowledge-only mode You've got two distinct documentation needs in your organization. Some processes absolutely need tracking (client onboarding, compliance audits). Others just need to be accessible and current. **Perfect for knowledge-only mode:** - Sales order entry steps - Do's and don'ts for customer calls - Equipment operating instructions - Software how-to guides - Company policies and guidelines - Emergency response procedures - Quick reference checklists These are procedures people reference while doing their work. They don't need task assignments or completion tracking - they need instant access to accurate information. ### Publishing procedures and documents Transform any template into searchable knowledge that's always current. Here's how: Your team searches for "sales order entry" and immediately finds the latest procedure. No hunting through outdated wikis or shared drives. Simple. ### Permission management for knowledge sharing Control who sees what without complexity. Tallyfy's permission system makes knowledge management straightforward. **View-only access**: Grant [Light members](/products/pro/documenting/members/light-members/) permission to view templates without launching them. Perfect for contractors or new hires who need reference materials but shouldn't start processes. **Department-specific knowledge**: Use [folders](/products/pro/documenting/templates/organize-templates-into-folders/) to organize procedures by department. Sales sees sales procedures. Operations sees operations procedures. No information overload. **Guest access for partners**: Share specific procedures with [guests](/products/pro/documenting/guests/) - like your suppliers who need to understand your receiving process. They see only what you share. ### Continuous improvement through comments Knowledge stays fresh when everyone contributes. Tallyfy makes improvement suggestions effortless. Every procedure template includes a comment section. When someone spots an outdated step or has a better method, they comment directly on the template. Process owners get notified instantly. Real example: A warehouse worker notices the receiving procedure references an old dock door number. They comment: "Step 3 should reference Dock 4, not Dock 2." The template owner updates it immediately. Everyone sees the correct information from that moment forward. Comments create an improvement culture. People feel heard. Procedures stay accurate. ### Smart search capabilities Finding the right procedure takes seconds with Tallyfy's [universal search](/products/pro/miscellaneous/how-to-use-tallyfys-universal-search-function/). Type any keyword - the system searches across: - Template titles and descriptions - Individual steps within templates - [Snippets](/products/pro/documenting/templates/snippets/) (reusable content blocks) - Comments and notes - Form field names Search "refund" and you'll find every procedure mentioning refunds - whether it's in the title, buried in step 7, or mentioned in a comment. Traditional documentation can't match this. ### Change management and watching Stay informed without information overload. Tallyfy's watching feature lets you monitor specific templates for changes. **Watch frequencies you control:** - **Instant**: Critical procedures where any change matters immediately - **Daily digest**: Batch updates for standard procedures - **Weekly summary**: Low-priority reference materials You're the quality manager watching all ISO procedures. Set them to instant notification. When someone updates a procedure, you know immediately. Review the change, approve it, and everyone works from the latest version. **What triggers notifications:** - Template content changes - New comments or improvement suggestions - Permission modifications - Automation rule updates ### Template within template embedding Build modular knowledge that eliminates repetition. Here's where Tallyfy shines for documentation. **Real scenario**: You have a "Pre-call checklist" template - verify customer account, review history, prepare notes. This checklist applies to multiple processes. Instead of copying these steps into every sales-related template, you embed the checklist template. Create your "Sales call" template and embed "Pre-call checklist" at the beginning. Create "Support call" template - embed the same checklist. When you improve the pre-call checklist, every template using it updates automatically. No manual copying. No version confusion. One source of truth. **Common embedded templates:** - Safety checks (embedded in all equipment procedures) - Data security protocols (embedded in IT processes) - Customer verification (embedded in service procedures) - Quality standards (embedded in production templates) ### Snippet management for consistent content [Snippets](/products/pro/documenting/templates/snippets/) are your secret weapon for maintaining consistent language across all procedures. Create a snippet for your standard confidentiality notice. Insert it into 50 different templates with two clicks. Need to update the legal language? Change the snippet once - all 50 templates update instantly. **High-value snippets to create:** - Legal disclaimers and compliance statements - Safety warnings and precautions - Contact information blocks - Standard operating conditions - Common troubleshooting steps - Glossary definitions Snippets ensure everyone uses approved language. Marketing won't accidentally use old taglines. Legal won't find outdated disclaimers. Consistency happens automatically. ### AI and MCP integration for intelligent search Connect Tallyfy's knowledge base to any AI platform through the [MCP server](/products/pro/integrations/mcp-server/). Your AI assistant can now search and retrieve procedures on demand. Employee asks ChatGPT: "How do I process a return?" The AI searches Tallyfy via MCP, finds your return procedure, and provides step-by-step guidance. The AI always references current procedures because it's pulling directly from Tallyfy. **Setup is straightforward:** 1. Enable MCP server in Tallyfy settings 2. Configure your AI platform to connect 3. Set appropriate access permissions 4. Test with common queries Your entire procedure library becomes AI-searchable. Teams get instant answers backed by your official procedures. ### Practical examples of knowledge-only use **Entering a sales order** - Your sales team needs quick reference while on customer calls. They pull up the procedure, follow along while entering the order, but don't need task tracking. Speed matters more than documentation. **Conference room setup** - Facilities posts the setup checklist as knowledge. Teams reference it when preparing rooms but don't need to log each chair placement. It's guidance, not governance. **Password reset procedures** - IT publishes step-by-step instructions. Employees follow them independently without creating tickets for simple resets. Knowledge-only mode reduces helpdesk load significantly. **Expense report guidelines** - Finance maintains current policies and examples. Employees reference them while completing reports in your expense system. The knowledge lives in Tallyfy; the task happens elsewhere. ### Setting up knowledge-only workflows Ready to implement? Here's your pathway to knowledge management success: Start with your top 10 most-requested procedures. Transform them into searchable templates. Watch your email volume drop as people find answers themselves. ### Measuring knowledge effectiveness Track whether your knowledge management works: **Usage metrics to monitor:** - Template view counts (high views = valuable content) - Search queries (reveals what people need) - Comment frequency (shows engagement) - Update frequency (indicates living documentation) A healthy knowledge base shows steady views, regular comments, and periodic updates. Dead documentation has zero views and years-old modified dates. **Success indicators:** - Fewer "how do I...?" emails and messages - New hires becoming productive faster - Reduced errors from following outdated procedures - Positive feedback about finding information easily ### Advanced knowledge management patterns **Versioned procedures with context** - Keep previous versions accessible but clearly marked. Sometimes you need to know what the procedure was last quarter for audit purposes. **Conditional knowledge display** - Use [automation rules](/products/pro/documenting/templates/automations/) to show different snippets based on user properties. Show region-specific regulations only to relevant teams. **Knowledge analytics integration** - Export view and search data to your [BI platform](/products/pro/integrations/analytics/). Understand which procedures drive value and which need retirement. **Collaborative knowledge building** - Use comments and [variables](/products/pro/documenting/templates/variables/) to crowdsource improvements. Teams contribute examples that make procedures clearer. ### Best practices for sustainable knowledge management **Keep it current** - Set quarterly reviews for critical procedures. Outdated knowledge is worse than no knowledge. **Write for scanning** - Use clear headings, bullet points, and bold key actions. People skim procedures while working. **Include examples** - Abstract instructions confuse. Concrete examples clarify. Show exactly what good looks like. **Link related content** - Connect procedures that work together. If "Process Order" mentions "Handle Returns," link them. **Verify accuracy** - Have subject matter experts review procedures before publishing. Incorrect procedures cause expensive mistakes. **Retire outdated content** - Archive obsolete procedures clearly. Don't let old versions create confusion. Knowledge-only mode transforms Tallyfy from a workflow engine into a complete operational knowledge platform. Your procedures become living documents that teams actually use and improve continuously. - **[Why training fails](https://tallyfy.com/products/pro/tutorials/why-documentation-training-fails-forgetting-curve/)**: Hermann Ebbinghaus's 1885 research revealed that humans forget 90% of learned information within seven days which explains why traditional business training programs and documentation systems fail to create lasting knowledge retention in organizations. ## The Ebbinghaus forgetting curve In 1885, German psychologist Hermann Ebbinghaus conducted groundbreaking experiments that revealed a startling truth about human memory: we forget information at an exponential rate. His research, replicated numerous times including a [detailed 2015 study](https://pmc.ncbi.nlm.nih.gov/articles/PMC4492928/), established what's now known as the **Ebbinghaus forgetting curve**: - **50% forgotten within 20 minutes** of learning - **60% forgotten within 1 hour** - **70% forgotten within 9 hours** - **90% forgotten within 7 days** Yet most organizations continue investing millions in training programs and documentation systems that ignore this biological reality. ![The forgetting curve visualized as a filing cabinet mind - DAY 1 drawer holds organized documents with green checkmarks, DAY 3 shows papers starting to escape, DAY 7 drawer is nearly empty with papers flying away and fading to grey, representing how 90% of training knowledge is lost within a week](https://screenshots.tallyfy.com/illustrations/forgetting-curve-v2.jpeg) ### Understanding the forgetting curve The forgetting curve is a mathematical model showing how information is lost over time when there's no attempt to retain it. Ebbinghaus tested himself by memorizing nonsense syllables (like "WID" or "ZOF") to eliminate the influence of prior knowledge, then measured how much effort it took to relearn them after various time intervals. **The curve reveals three critical insights:** 1. **Forgetting is exponential, not linear**: Most forgetting happens immediately after learning, with the steepest decline in the first hour 2. **Sleep creates a retention bump**: There's a slight improvement in memory after 24 hours, likely due to sleep consolidation 3. **Without reinforcement, nearly everything is forgotten**: After a month, retention approaches zero for most information ### Impact on business operations Consider the typical business approach to knowledge transfer: - **New employee training**: Multi-day sessions covering policies, procedures, and systems - **Process documentation**: Lengthy PDFs or wiki pages explaining how to perform tasks - **Annual compliance training**: Required courses that employees complete once per year - **Expert knowledge transfer**: Sitting with experienced staff to learn complex procedures According to the forgetting curve, **90% of this investment is wasted**. By the time employees need to apply what they learned, they've forgotten almost everything except vague impressions. ### Flaws in traditional approaches #### The "Learn Then Do" Fallacy Traditional approaches assume people can: 1. Learn information in advance 2. Store it in memory 3. Retrieve it perfectly when needed This model fails because: - **Time gap**: Days or weeks often pass between learning and application - **Context mismatch**: Training environments differ from real work situations - **Information overload**: People are taught everything at once rather than what's immediately relevant - **No retrieval practice**: Information isn't reinforced at the moment of need #### The documentation paradox Organizations create extensive documentation believing it solves knowledge management, but: - **If people remember the process**, they don't need documentation - **If people forget the process**, they also forget that documentation exists or where to find it - **Even when found**, interpreting written procedures requires cognitive effort and leaves room for error #### The expert dependency trap When formal methods fail, organizations fall back on tribal knowledge: - Experts become bottlenecks as everyone depends on their availability - New employees require extended mentorship periods - Knowledge walks out the door when experts leave - Inconsistent execution as each expert develops their own methods ### Industry examples #### Healthcare - **Training reality**: Nurses receive intensive orientation on medication protocols - **Forgetting impact**: Months later, facing a rarely-used medication, critical steps are forgotten - **Consequences**: Medication errors, one of the leading causes of patient harm #### Financial services - **Training reality**: Extensive compliance training on anti-money laundering procedures - **Forgetting impact**: When suspicious activity occurs, staff forget specific reporting requirements - **Consequences**: Regulatory violations, fines, reputational damage #### Manufacturing - **Training reality**: Safety procedures taught during onboarding - **Forgetting impact**: Workers skip critical safety steps they can't recall - **Consequences**: Workplace accidents, production delays, liability issues - **Language complexity**: Multinational manufacturing facilities face additional challenges when safety procedures must be understood across multiple languages - forgetting curve effects are magnified when training occurs in non-native languages #### Professional services - **Training reality**: Complex client onboarding procedures explained in training - **Forgetting impact**: Steps are missed or performed incorrectly months later - **Consequences**: Client dissatisfaction, rework, lost revenue ### Neuroscience insights Modern neuroscience has validated and expanded Ebbinghaus's findings: #### Working memory limitations - Human working memory can only hold 7±2 items at once - Complex procedures quickly overwhelm this capacity - Cognitive load increases errors and slows performance #### Declarative vs. Procedural Memory - **Declarative memory** (facts and procedures) fades quickly without use - **Procedural memory** (motor skills like riding a bike) lasts longer but requires extensive practice - Business processes rely heavily on declarative memory, making them vulnerable to forgetting #### Context-Dependent Memory - Information learned in one context (training room) is harder to recall in another (workplace) - Stress and time pressure further impair memory retrieval - Real-world application rarely matches training conditions - Language barriers compound memory challenges - employees may struggle to recall procedures explained in non-native languages, particularly under pressure ### Overcoming the forgetting curve Instead of relying on memory, successful organizations: #### 1. Eliminate the Need to Remember Rather than teaching people what to do and hoping they remember, guide them through each step in real-time: - **Just-in-time guidance**: Provide instructions at the moment of need - **Progressive disclosure**: Show only relevant information for the current step - **Contextual help**: Embed explanations and resources within the workflow #### 2. Standardize Through Systems, Not Memory - **Digital workflows**: Encode procedures in systems that guide execution - **Automated routing**: Remove the need to remember who does what - **Built-in validation**: Prevent errors through system constraints, not human recall #### 3. Make Knowledge Retrieval Effortless - **Search-free access**: Users shouldn't need to remember where information lives - **Role-based visibility**: Show only relevant procedures to each user - **Mobile accessibility**: Enable access wherever work happens #### 4. Continuous Reinforcement Without Training - **Learning by doing**: Each process execution reinforces the procedure - **Incremental complexity**: Start with simple tasks and gradually increase sophistication - **Feedback loops**: Immediate confirmation of correct actions ### Workflow management systems Tallyfy workflow management systems succeed because they **bypass memory entirely**. Instead of asking people to remember procedures, they: **Provide Real-Time Guidance** - Step-by-step instructions appear exactly when needed - No time gap between learning and doing - Context-specific help for each situation **Enforce Consistency Through Structure** - Required fields ensure nothing is missed - Conditional logic handles variations automatically - Approval workflows prevent unauthorized deviations **Enable Learning Through Repetition** - Each process execution reinforces the pattern - Improvements are immediately available to all users - New employees can perform complex tasks from day one **Create Institutional Memory** - Knowledge is stored in the system, not individual minds - Process history provides learning examples - Updates propagate instantly to all users ### Hidden costs Organizations that rely on traditional training and documentation face hidden costs: #### Quantifiable losses - **Training investment waste**: 90% of training budget provides no lasting value - **Productivity loss**: Employees spend hours searching for forgotten information - **Error rates**: Forgotten steps lead to mistakes requiring rework - **Compliance failures**: Forgotten procedures result in regulatory violations #### Hidden impacts - **Employee frustration**: People feel incompetent when they can't remember training - **Customer dissatisfaction**: Inconsistent service delivery damages relationships - **Innovation barriers**: Time spent relearning basics prevents improvement focus - **Scaling limitations**: Growth becomes impossible when knowledge transfer fails ### Diagnostic questions 1. **How long after training do employees first use what they learned?** - If more than a week, you're already at 90% forgetting 2. **What percentage of documented procedures are regularly referenced?** - Unused documentation indicates reliance on memory 3. **How often do employees ask colleagues "How do I do this?"** - Frequent questions reveal forgotten training 4. **How many errors trace back to missed or incorrect steps?** - Process errors often indicate memory failures 5. **How long does it take new employees to work independently?** - Extended mentorship suggests ineffective knowledge transfer ### Path forward Successful organizations: **Accept Biological Reality** - Stop expecting people to remember complex procedures - Design systems that work with human limitations - Focus on execution support rather than information retention **Invest in Systems, Not Training** - Shift budget from training programs to workflow systems - Measure success by consistent execution, not test scores - Value real-time guidance over advance preparation **Create Adaptive Processes** - Build flexibility into workflows rather than rigid procedures - Enable continuous improvement based on execution data - Empower employees to succeed without perfect memory By providing real-time guidance exactly when needed, workflow management systems bypass memory limitations entirely. Organizations that accept this reality and design around it achieve consistent execution, reduced errors, and scalable growth. - **[Navigate Tallyfy](https://tallyfy.com/products/pro/tutorials/navigate-tallyfy/)**: The Tallyfy platform interface features a left sidebar with navigation options like CREATE TASKS and TRACKER along with a universal search bar and top icons for language selection and notifications to help users efficiently manage workflows and find information. ## How to navigate the Tallyfy platform interface Tallyfy workflow management uses several key interface areas to help you find information and manage workflow tasks effectively. ### What is the left sidebar menu in Tallyfy? The left sidebar serves as your primary navigation tool in Tallyfy, located on the left side of the screen. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-sidebar-numerated.png) 1. **+ CREATE**: Start new workflow items like processes, templates, or tasks 2. **HOME**: Go to your main Tallyfy dashboard view 3. **TASKS**: See your personal task assignments ([learn more](/products/pro/tracking-and-tasks/tasks/)) 4. **TRACKER**: View all active workflow processes ([learn more](/products/pro/tracking-and-tasks/tracker-view/)) 5. **TEMPLATES**: Access your library of workflow templates ([learn more](/products/pro/documenting/templates/)) 6. **PEOPLE**: Manage team members (Administrators only) 7. **INVITE+**: Invite new members to join your Tallyfy organization 8. **GUIDE**: Open the Tallyfy help documentation 9. **SUPPORT**: Contact the Tallyfy support team 10. **SETTINGS**: Access your personal and Tallyfy organization settings :::note[Visibility depends on your role] Some sections, like **People** or certain **Settings**, are only visible if you have the Administrator role. Standard and Light roles have different access levels. ::: ### How does Tallyfy's universal search work? ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-search-bar-results.png) The universal search bar at the top allows you to find items across your entire Tallyfy account. You can search for processes, templates, tasks, snippets, and team members by typing keywords. * **Sharing Search Results**: Click the share icon next to any Tallyfy search result to copy a direct link to that item ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-copy-search-result-link.png) ### What are the top bar icons in Tallyfy? * **Language Selector** (Globe icon 🌐): Click to change the display language for Tallyfy menus and buttons. If your organization uses the [Azure Translation integration](/products/pro/integrations/azure-translation/), you can also select a language for automatic content translation ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-change-language.png) * **Notifications** (Bell icon 🔔): Click to view recent notifications about task assignments, comments, and other workflow activities. See [Check Notifications](/products/pro/tracking-and-tasks/how-can-i-view-notifications-in-tallyfy/) - **[Launch a process](https://tallyfy.com/products/pro/tutorials/your-first-process/)**: This tutorial demonstrates launching workflow processes in Tallyfy by navigating to templates selecting the desired template clicking Launch Process completing any kick-off forms naming the instance optionally reviewing settings and finalizing the launch to create an active trackable workflow with automatic notifications. ## How to launch your first workflow process in Tallyfy This tutorial shows you how to launch a [process](/products/pro/tracking-and-tasks/processes/) from a [template](/products/pro/documenting/templates/) you have already created. A Tallyfy process is a specific workflow instance that runs from your template blueprint. :::tip[Need to add tasks later?] If you need to add a step that wasn't part of the original template, you can add [ad-hoc tasks](/products/pro/tracking-and-tasks/processes/edit-processes/how-can-i-add-tasks-to-active-processes-on-tallyfy/) to any running process. ::: - **[Create your first template](https://tallyfy.com/products/pro/tutorials/your-first-template/)**: Tallyfy enables users to create workflow templates through AI-powered generation manual creation from scratch or document conversion with the AI method allowing rapid development by simply describing the desired business process and generating structured steps automatically. ## Creating your first workflow template ![Getting started with templates visualized as a blank canvas on the left transforming into a structured workflow template with connected steps on the right - representing the journey from idea to executable process](https://screenshots.tallyfy.com/illustrations/getting-started.jpeg) This tutorial shows how to create your first process template in Tallyfy for workflow standardization. Tallyfy templates work as reusable blueprints for your repeatable business workflows, letting you execute them consistently across your organization. ### Creating a template with Tallyfy AI This example shows how to use Tallyfy AI to create workflow templates quickly and efficiently. ### Alternative template creation methods Besides using Tallyfy AI, you can also create workflow templates using these methods: * **From Scratch**: Build your workflow template step-by-step manually for complete customization * **From SOP document**: Upload an existing Word document, PDF, or flowchart file. Tallyfy AI will convert it into a structured template for quick migration Each method serves different needs based on your starting point and customization requirements. See [Create a Template](/products/pro/documenting/templates/create-template/) for detailed information on all methods. - **[How-to guides](https://tallyfy.com/products/pro/tutorials/how-to/)**: Tallyfy's how-to guides offer task-focused instructions and real-world implementation approaches to help users solve common workflow challenges and optimize their business processes more effectively. ## What are Tallyfy's how-to guides? This section offers practical guides to help you solve common workflow challenges using Tallyfy. Each how-to guide examines specific business situations and provides effective ways to handle them. These how-to guides complement our feature documentation by demonstrating how Tallyfy workflow features can be combined to solve real-world business problems effectively. ### What how-to guides are available? Browse our complete collection of Tallyfy how-to guides below: ### What are the benefits of using these how-to guides? - **Task-focused instructions**: Step-by-step help for common workflow issues - **Implementation approaches**: Ideas based on real Tallyfy customer implementations - **Efficiency tips**: Suggestions to help your team work more productively - **Process optimization**: Ideas for making your business workflows more effective When you have suggestions for other how-to guides you'd find helpful, please contact our Tallyfy support team. - **[Key features](https://tallyfy.com/products/pro/tutorials/features/)**: Tallyfy offers comprehensive workflow management features including real-time status tracking intelligent automation through conditional logic external guest collaboration and advanced process optimization that transform static documentation into dynamic trackable workflows for operational excellence. ## Key platform features for workflow management This section highlights core concepts and advanced features that establish Tallyfy as a powerful workflow management solution for modern organizations. Explore detailed documentation covering essential capabilities including real-time status tracking, intelligent workflow automation through conditional logic, external guest collaboration, and advanced process optimization techniques. These Tallyfy features enable organizations to transform static documentation into dynamic, trackable workflows that drive operational excellence across departments. ## Exploring platform features Browse through these feature pages for a detailed understanding of Tallyfy's capabilities: ## Getting personalized assistance To discuss anything else, including discounts or specific help you need, please schedule a chat with us [here](https://tallyfy.com/booking/) for direct support. Our team provides customized guidance based on your specific workflow requirements and organizational needs. ### How to - **[Build effective forms](https://tallyfy.com/products/pro/tutorials/how-to/build-effective-forms/)**: Tallyfy's integrated approach to form building connects form submissions directly to trackable workflows while offering features like email verification conditional branching field validation and document generation to create seamless end-to-end processes rather than isolated data collection. ## Building forms in Tallyfy Tallyfy integrates forms directly with the workflow steps that follow. Unlike standalone form tools, Tallyfy connects data collection to the actual work - forms trigger trackable processes automatically. ### Form submission triggers processes With standalone form tools, users often wonder what happens after they click submit. Tallyfy connects submission directly to a trackable workflow: - **From "submit" to "submit and track"**: Tallyfy links form submission to the first step of a visible, trackable workflow. - **Integrated process context**: Forms start processes that already have context and defined action steps. - **End-to-end visibility**: Submitters can see what happens to their request after submission. - **Continuous visibility**: Access status updates, approvals, and downstream task progress. Tallyfy calls these initial forms "kick-off forms" because they start processes, not just collect data. ### Email verification for public forms Public forms can cause problems if submitters use fake or wrong email addresses: - **Email verification**: Tallyfy's public kick-off forms include email verification to confirm submitters are genuine. - **Secure access links**: Submitters get unique links via email to access and finish forms. - **Permanent tracking**: This verification also lets submitters track the status of their submission later. - **Reduced spam**: Verification helps cut down on form spam and fake entries. :::tip[Accessing public forms] To allow public access to your kick-off forms, go to the template editor, find the **Triggers** section, and switch **Public Sharing** to **ON**. You can then copy and share the public link provided. ::: ### Selecting field types - **Short text**: For names, references, or short answers (max 200 characters). - **Long text**: For detailed descriptions or notes (max 6,000 characters). - **Dropdown**: For selecting one option from a predefined list. - **Radio buttons**: For choosing one option when only a few choices are available. - **Checklist**: For selecting multiple items or verifying steps. - **Date**: For capturing specific dates (e.g., deadlines, start dates). - **File upload**: For collecting documents or images. - **Table**: For structured data that repeats (like line items). - **Assignee picker**: For letting the submitter choose who should do a later task. Tallyfy's [form builder software](https://tallyfy.com/solutions/form-builder-software/) offers [validation options](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) for each field type, helping ensure data is complete and correctly formatted. ### Breaking forms into steps Instead of showing one very long form, Tallyfy lets you spread form fields across multiple steps: - **Progressive data collection**: Gather information step by step. - **Real-time saving**: Entries are saved as they are typed, reducing lost work. - **Automated reminders**: Tallyfy can send reminders for incomplete steps. - **Improved completion rates**: Shorter forms at each stage can lead to more completed submissions. - **Focused attention**: Users concentrate on smaller sets of questions at a time. :::note[Keep kick-off forms short] Make your initial kick-off form brief, asking only for essential information to start the process. You can gather more details in later steps. This lowers the barrier for starting and ensures necessary info is collected when needed. ::: ### Conditional branching Not all questions apply to everyone. Tallyfy's "if-this-then-that" [automation rules](/products/pro/documenting/templates/automations/) allow forms to adapt: - **Conditional visibility**: Show or hide steps based on answers to previous questions. - **Targeted information**: Ask only relevant questions for specific situations. - **Relevant user experience**: Users don't see fields that don't apply to them. - **Reduced abandonment**: Keeping forms focused helps increase completion rates. Using [conditional branching](/products/pro/documenting/templates/automations/logic-explained/) means users only see and fill out fields relevant to their specific situation. ### Field validation - **Input validation**: Ensure formats for emails, numbers, dates, etc., are correct. - **Required fields**: Make sure critical information isn't missed. - **Character limits**: Set minimum/maximum lengths for text fields. - **Custom validation**: Apply specific rules if needed. - **Error messages**: Guide users to fix mistakes. Tallyfy's [validation options](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/#short-text-field) for each field type help ensure data meets your requirements. ### Adding help text - **Field guidance**: Add explanatory text below a field label. - **Contextual help**: Give examples or formatting tips. - **Tooltips and hints**: Offer extra info without cluttering the form. - **Precise labeling**: Use clear, descriptive labels for fields. - **Consistent formatting**: Use the same style for help text across forms. Tallyfy lets you add guidance text to any form field, reducing confusion and improving data quality. ### Built-in communication Unlike many form tools, Tallyfy has communication built-in: - **Contextual comments**: Users can ask questions directly on the form or task. - **\@mentions**: Tag specific team members to get their attention. - **Comment history**: Keep a record of discussions for future reference. - **Notification system**: Alert people when comments need attention. ### Data distribution and integration - **Webhook integration**: Send form data automatically to other systems. - **API connections**: Connect Tallyfy to other business software for data sharing. - **Document generation**: Use form data to automatically fill out document templates. - **Reporting**: Analyze form responses. - **Data exports**: Get form data into spreadsheets or other formats. Tallyfy's [webhooks](/products/pro/documenting/documents/how-to-generate-documents-from-form-fields/) and [integration options](/products/pro/integrations/middleware/how-can-i-export-form-fields-from-tallyfy-to-spreadsheet/) ensure collected data can be used effectively elsewhere. ### Collaborative form completion - **Assignee management**: Allow form starters to assign steps to the right team members. - **Guest access**: Include external people in the process securely. - **Task reassignment**: Reassign tasks if the original person isn't available. - **Group assignments**: Assign steps to teams. - **Parallel completion**: Allow different parts of a form or process to be done simultaneously. ### Document generation from forms Tallyfy lets you create documents automatically from form submissions: - **Template-based documents**: Fill documents like contracts or letters with form data. - **Dynamic content**: Create documents that change based on form answers. - **Formatted output**: Generate branded PDFs or other formats. - **Multi-stage approval**: Include review steps in the document workflow. - **Revision tracking**: Keep a history of document versions. For example, a form can collect client details, project scope, and pricing, then automatically generate a contract PDF. :::tip[Document generation setup] To set up document generation: 1. Use the [document generation integration](/products/pro/documenting/documents/how-to-generate-documents-from-form-fields/) to link form fields to document templates. 2. Map form fields to placeholders in your document templates. 3. Configure middleware platforms (like Zapier, Make, n8n) to handle document creation. 4. Set up delivery steps (e.g., email, storage) as later tasks. ::: :::note[Considering integration alternatives] While Zapier works for simple connections, we often recommend more powerful and cost-effective middleware like **n8n**, **Make**, or **Microsoft Power Automate** for robust integrations. For maximum control, especially with development resources, consider Tallyfy's [Open API](/products/pro/integrations/open-api/) to build custom integrations, perhaps using AI to help write code for serverless functions. ::: ### Additional form features - **Mobile optimization**: Ensure forms work well on phones and tablets. - **Consistent branding**: Match your organization's look and feel. - **Progress indicators**: Show progress in multi-step forms or processes. - **Default values**: Pre-fill fields with common answers where appropriate. See [Set default content for form fields](/products/pro/tracking-and-tasks/tasks/how-to-set-default-content-for-form-fields/) for detailed setup instructions. - **Clear next steps**: Tell users what happens after submission. - **Accessibility**: Design for users with disabilities. - **Testing**: Test forms with users before wide release. - **Analytics integration**: Track completion rates and drop-off points. - **Continuous improvement**: Update forms based on feedback. - **[Eliminate tribal knowledge](https://tallyfy.com/products/pro/tutorials/how-to/eliminate-tribal-knowledge-with-workflow-documentation/)**: Tribal knowledge represents critical business information and processes that exist only in individual employees' minds rather than being systematically documented creating significant organizational vulnerabilities operational inefficiencies and business risks that can be eliminated through structured workflow systems like Tallyfy. ## What is tribal knowledge and why is it a business risk? ![Tribal knowledge visualized as a glowing orb held by one person while colleagues stand in shadows - representing critical business information trapped in individual minds rather than shared across the organization](https://screenshots.tallyfy.com/illustrations/tribal-knowledge.jpeg) Tribal knowledge refers to critical business information and Tallyfy processes that exist only in individual employees' heads rather than being systematically documented. This creates significant organizational vulnerabilities and operational inefficiencies. The problem is compounded by the [Ebbinghaus forgetting curve](/products/pro/tutorials/why-documentation-training-fails-forgetting-curve/), which shows that people forget 90% of what they learn within 7 days. Even when organizations attempt to transfer tribal knowledge through training, the biological reality of human memory ensures most of this knowledge is quickly lost. Common tribal knowledge scenarios include: - **Expert mentorship requirements**: New employees must sit with experienced staff multiple times to learn processes - **Single points of failure**: When key personnel are sick, on vacation, or leave the company, operations suffer - **Inconsistent execution**: The same process is performed differently by different people, leading to errors and quality issues - **Training bottlenecks**: Onboarding requires extensive one-on-one time with subject matter experts ### What industries are most affected by tribal knowledge problems? While tribal knowledge affects all industries, certain sectors face particularly acute challenges: #### Insurance and financial services - Complex underwriting processes with carrier-specific procedures - Regulatory compliance requirements that vary by jurisdiction - Endorsement and claims processing with multiple conditional pathways - Risk assessment procedures requiring specialized expertise #### Professional services - Client onboarding procedures with industry-specific requirements - Proposal development and project delivery methodologies - Quality assurance and review processes - Billing and invoicing procedures with client-specific variations #### Healthcare and Regulated Industries - Patient care protocols and treatment pathways - Compliance procedures for regulatory submissions - Equipment maintenance and safety procedures - Documentation requirements for auditing purposes ### How does tribal knowledge impact business operations? #### Operational risks - **Scalability limitations**: Growth becomes difficult when processes can't be replicated - **Quality inconsistency**: Outcomes vary depending on who performs the work - **Knowledge loss**: Critical expertise disappears when employees leave - **Training inefficiency**: New hires require extensive mentorship periods #### Financial impact - **Increased training costs**: Extended onboarding periods for new employees - **Productivity delays**: Work stops when key personnel are unavailable - **Error rates**: Inconsistent execution leads to mistakes and rework - **Opportunity costs**: Time spent on repetitive training instead of value-added activities ### How does Tallyfy systematically eliminate tribal knowledge? #### Step 1: Knowledge Capture Transform expert knowledge into structured, repeatable workflows: - **Process documentation**: Convert mental models into step-by-step procedures - **Conditional logic capture**: Document decision trees and "if-this-then-that" scenarios - **Context preservation**: Include background information and reasoning for each step - **Exception handling**: Document how to handle unusual situations and edge cases #### Step 2: Systematic Execution Ensure consistent process execution regardless of who performs the work: - **Guided workflows**: Lead users through each step with clear instructions - **Automatic routing**: Direct tasks to appropriate team members based on defined rules - **Built-in validation**: Include checkpoints and approval steps to maintain quality - **Progress tracking**: Monitor completion status and identify bottlenecks in real-time #### Step 3: Continuous Improvement Refine processes based on actual execution data and user feedback: - **Performance analytics**: Identify steps that consistently take longer or cause confusion - **User feedback**: Collect suggestions for improvement through task comments - **Version control**: Update processes while maintaining audit trails of changes - **Knowledge sharing**: Enable teams to learn from each other's experiences ### What specific tribal knowledge challenges does Tallyfy address? #### Training and Onboarding Bottlenecks **Problem**: "I have to sit with new employees multiple times while they go through the process, then sit with them again while they do it independently." **Tallyfy Solution**: - Self-guided workflows that don't require expert presence - Embedded instructions, videos, and reference materials within each step - Progressive complexity allowing new hires to start with simpler processes - Built-in checkpoints where supervisors can review without being present throughout #### Process variation and inconsistency **Problem**: "Every time we do this process, it's different. It follows the same vague flow, but the details are always different." **Tallyfy Solution**: - Standardized step sequences that ensure consistent execution - Conditional automations that handle variations systematically - Required fields and validations that prevent steps from being skipped - Audit trails showing exactly how each instance was completed #### Knowledge dependency and single points of failure **Problem**: "If that person leaves or is sick, we could be entirely screwed because they're the only one who knows how to do it." **Tallyfy Solution**: - Process knowledge stored in the system rather than individuals' heads - Cross-training capabilities through standardized procedures - Multiple people can be trained on the same documented process - Knowledge retention even when experts leave the organization #### Complex conditional processes **Problem**: "There's a lot of branching based on different scenarios, but you don't know where you're branching until you get to that stage." **Tallyfy Solution**: - Conditional logic that reveals appropriate steps based on earlier inputs - Progressive information gathering rather than requiring all details upfront - Dynamic workflows that adapt based on specific case requirements - Clear decision points with documented criteria for each path ### How can organizations implement systematic knowledge capture? #### Phase 1: Identify Critical Processes Start with processes that have the highest tribal knowledge risk: - Processes performed by only one or two people - Procedures with complex decision trees or many exceptions - Activities that require extensive training periods - Tasks where inconsistency creates quality or compliance issues #### Phase 2: Expert Collaboration Work with subject matter experts to document their knowledge: - **Interview sessions**: Walk through processes step-by-step with experts - **Process observation**: Watch experts perform the work and document their actions - **Exception documentation**: Capture how experts handle unusual situations - **Decision criteria**: Document the reasoning behind expert judgment calls #### Phase 3: Template Creation Transform captured knowledge into executable Tallyfy templates: - **Sequential steps**: Break down processes into logical, ordered steps - **Assignment rules**: Define who should perform each step or type of step - **Conditional logic**: Implement branching scenarios using automations - **Supporting materials**: Embed reference documents, videos, and resources #### Phase 4: Testing and Refinement Validate documented processes through controlled execution: - **Pilot testing**: Have non-experts attempt to follow the documented process - **Expert review**: Have original experts verify accuracy and completeness - **Gap identification**: Identify missing steps or unclear instructions - **Iterative improvement**: Refine templates based on testing feedback ### What best practices ensure successful tribal knowledge elimination? #### Start with High-Impact, Lower-Complexity Processes - Choose processes that are frequently performed but not overly complex - Focus on procedures that create bottlenecks when experts are unavailable - Prioritize processes where consistency directly impacts quality or compliance #### Involve multiple subject matter experts - Include different experts who perform the same process to capture variations - Validate documented procedures with multiple knowledgeable individuals - Identify and resolve conflicting approaches before finalizing templates #### Include context and reasoning - Document not just what to do, but why certain steps are important - Explain the business impact of skipping or incorrectly performing steps - Provide background information that helps users make informed decisions #### Plan for Exception Handling - Document common exceptions and how to handle them - Create escalation procedures for unusual situations not covered in standard workflows - Include contact information for subject matter experts when specialized knowledge is needed #### Maintain and Update Documentation - Assign ownership for keeping processes current as business requirements change - Establish regular review cycles to ensure procedures remain accurate - Create feedback mechanisms for users to suggest improvements based on real-world experience By systematically capturing and structuring tribal knowledge, organizations eliminate single points of failure while ensuring consistent, high-quality execution regardless of staff changes or availability. - **[Ensure task completion](https://tallyfy.com/products/pro/tutorials/how-to/ensure-task-completion/)**: Tallyfy ensures task and approval completion through automated reminders clear task definitions escalation paths bundling related work comment-based follow-ups personal communication context explanations and recognition strategies to prevent delays and maintain workflow accountability. ## Ensuring task and approval completion Tallyfy provides automated reminders, clear task definitions, and escalation paths to ensure tasks and approvals get completed on time. ### Automated reminders Tallyfy automatically sends task reminders: - **Automated email digests**: Tallyfy automatically sends scheduled reminders based on each user's settings. - **Customizable frequency**: Users can adjust reminder frequency in their [notification settings](/products/pro/settings/personal-settings/how-can-i-manage-email-notifications-in-tallyfy/). - **Manual reminders**: For urgent items, you can [send immediate email reminders](/products/pro/tracking-and-tasks/tasks/how-can-i-send-email-reminders-in-tallyfy/) to assignees. ### Creating clear tasks Tasks need: - **Defined purpose**: Every task needs a clear goal and reason. - **Appropriate scope**: Tasks should be significant but not overwhelming. - **Defined requirements**: Explain what "done" looks like for the task. - **Reasonable deadlines**: Set achievable deadlines allowing for quality work. :::tip[Avoiding task fatigue] Avoid creating too many small, minor tasks. This can lead to "approval fatigue" where people ignore notifications. Keep tasks meaningful to maintain their importance. ::: ### Consolidating related work Group related items to reduce task overload and prevent [task debt](/products/pro/tutorials/how-to/how-to-avoid-task-debt/): - **Bundle related approvals**: Combine multiple related approvals into one step if possible. - **Use form fields**: Use a single form with multiple fields instead of many separate tasks for collecting information. - **Create logical sequences**: Organize tasks to flow smoothly without repeating work. - **Consider workload balance**: Be mindful of how many tasks you assign to individuals. - **Use expiring tasks for FYI items**: Convert informational tasks to [expiring type](/products/pro/tracking-and-tasks/tasks/what-types-of-tasks-can-i-create-with-tallyfy/) so they auto-complete if not reviewed, preventing buildup. ### Using comments for follow-up Tallyfy's built-in comments let you ask about task status directly: 1. Open the relevant task. 2. Add a comment in the comments section. 3. Use \@mentions (e.g., `@username`) to notify specific people. 4. Keep comments focused on the task. Comments create an audit trail and notify assignees directly within the task. ### Adding personal communication For critical tasks or ongoing delays, add personal communication to digital reminders: - Schedule brief check-in calls to discuss obstacles. - Mention task status in regular team meetings. - Use chat/instant messaging for quick reminders. - Meet in person (if possible) for high-priority items. ### Explaining task importance Include context in task descriptions: - **Explain the purpose**: Clearly state why the task matters in its description. - **Connect to larger goals**: Show how the task helps meet team or company goals. - **Highlight impact**: Explain who benefits from the task getting done. - **Provide context**: Include background information if it helps understanding. ### Setting up escalation paths When tasks remain incomplete despite reminders, set up an escalation process: - **Reassign to managers**: Use Tallyfy's edit feature to [add the team member's manager](/products/pro/tracking-and-tasks/tasks/edit-task/how-can-i-assign-members-to-tasks-in-tallyfy/) as an assignee. - **Use \@mentions in comments**: Tag managers or senior members in comments to highlight the delay. - **Implement status actions**: Use [automation rules](/products/pro/documenting/templates/automations/actions/status-actions/) to trigger actions (like notifications) if tasks pass deadlines. - **Document patterns**: Track recurring issues to identify and fix underlying problems. ### Additional strategies - **Recognition and appreciation**: Thank team members who consistently complete tasks on time. - **Performance tracking**: Use Tallyfy reports to identify patterns and address issues early. - **Simplified interface**: Help team members focus by creating custom views of their priority tasks. - **Training and support**: Ensure everyone knows how to use Tallyfy effectively. - **Process optimization**: Regularly review processes to remove unnecessary tasks. - **[Effective operations manuals](https://tallyfy.com/products/pro/tutorials/how-to/build-effective-operations-manual/)**: Tallyfy transforms traditional operations manuals from static documentation into dynamic digital workflows by converting existing documents into interactive processes with automated rules clear ownership structures rich media support real-time tracking and continuous improvement mechanisms that ensure consistent execution across teams and devices. ## How to build an operations manual ![Operations manual transformation visualized as dusty binders and paper documents on the left flowing into a modern digital interface with live workflows on the right - representing the shift from static documentation to dynamic executable processes](https://screenshots.tallyfy.com/illustrations/operations-manual.jpeg) An operations manual is key for standardizing Tallyfy procedures, keeping company knowledge, and maintaining consistent quality. Traditional paper manuals can quickly become outdated and, worse still, even when people read them they [forget 90% within a week](/products/pro/tutorials/why-documentation-training-fails-forgetting-curve/). Tallyfy helps turn static documents into dynamic, usable processes using its [operations manual software](https://tallyfy.com/solutions/operations-manual-software/). ### Use digital, device-friendly documentation Paper binders and static PDFs aren't ideal for today's digital work environments: - **Automatic conversion**: Upload existing Word docs, PDFs, etc., to Tallyfy. It automatically converts them into web formats accessible on any device. - **Rich media support**: Add images, videos, and interactive elements to instructions, going beyond just text. - **Universal accessibility**: Ensure your team can access procedures anytime, anywhere, on any device. :::tip[Simplifying migration] When importing existing documents, start with your core procedures. Tallyfy's conversion features can help turn old documents into interactive processes. ::: ### Replace flowcharts with actionable automations Flowcharts can sometimes be complex and hard to follow: - **Flowchart conversion**: Upload existing flowcharts to Tallyfy for automatic conversion. - **Simple automation rules**: Replace decision points (diamonds) with simple "if-this-then-that" rules using [Tallyfy Automations](/products/pro/documenting/templates/automations/). - **Dynamic process flows**: Create processes that adapt based on inputs, decisions, or changing situations. This changes diagrams into processes that guide users step-by-step while following business rules. ### Establish ownership and responsibility Operations manuals need clear owners for both the overall system and individual procedures: - **System owner**: Appoint one person to oversee all operations documentation. - **Template owners**: Assign specific process owners using [Tallyfy's folder organization](/products/pro/documenting/templates/how-to-manage-templates-and-processes-with-tags/) in the **Templates** section. - **Accountability tracking**: Keep a record of who created and last updated each process template. Documenting ownership helps avoid situations where knowledge is only in someone's head. ### Organize with a logical hierarchy A clear structure makes finding procedures easier: - **Folder hierarchies**: Use Tallyfy's folders to group related templates logically. - **Tagging system**: Use [template tags](/products/pro/documenting/templates/how-to-manage-templates-and-processes-with-tags/) for filtering and organizing across different categories. - **Naming conventions**: Create consistent naming patterns that clearly identify each template's purpose. This structure helps team members find the procedures they need quickly. ### Document task information For each procedure, include key details: - **Task definition**: Clearly state the task and its purpose. - **Step-by-step instructions**: Detail how to perform each part of the task. - **Role assignments**: Assign responsibility for each step. - **Timing guidance**: Indicate when tasks should be done and expected durations. - **Required resources**: List necessary systems, tools, or materials. Using Tallyfy's [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) and task types helps capture this information in a structured way. ### Transform documentation into active execution An operations manual is most useful when people follow the procedures: - **Launch processes**: Turn static documents into active work by launching processes from Tallyfy templates. - **Real-time tracking**: Monitor who has completed which steps using Tallyfy's dashboard. - **Automated progression**: Automatically move work forward as steps are completed. Tallyfy makes procedures actionable with built-in tracking. :::note[Tracking execution metrics] Use Tallyfy's tracking to measure how often procedures are followed. This data helps identify processes needing updates or more training. ::: ### Add clarity with rich media Visuals help people understand and remember procedures better: - **Incorporate screenshots**: Show users exactly what they should see. - **Embed videos**: Demonstrate how to perform tasks. - **Link to resources**: Connect to related materials or examples. Using rich media can reduce misunderstandings and training time. ### Implement access controls Not everyone needs permission to edit operations documents: - **Role-based permissions**: Set up [permissions in Tallyfy](/products/pro/documenting/members/how-do-i-manage-member-permissions-in-tallyfy/) to control who can view, use, or edit templates. - **Centralized administration**: Keep overall control while giving appropriate access. - **Version control**: Protect approved procedures while allowing controlled updates. Access controls stop unwanted changes while ensuring people have the information they need. ### Measure engagement Analytics show how your operations manual is being used: - **Google Analytics integration**: Track reading statistics and engagement. - **Usage patterns**: See which procedures are used or run most often. - **Completion rates**: Monitor how often processes are completed successfully. These numbers help identify valuable procedures and areas for improvement. ### Support multilingual operations For teams working in different languages: - **Create master templates**: Develop procedures in your organization's primary language. - **Enable automatic translation**: Use Tallyfy's content translation feature to create versions in other languages. - **Maintain consistency**: Updates to the master template can automatically apply to translated versions. This ensures consistent procedures globally and reduces manual translation work. ### Establish continuous improvement mechanisms An operations manual should change as your organization changes: - **Encourage improvement comments**: Use Tallyfy's [commenting system](/products/pro/tracking-and-tasks/tasks/how-to-report-and-resolve-issues-in-tallyfy/) for feedback. - **Regular review cycles**: Schedule periodic reviews of procedures with their owners. - **Track change history**: Keep records of updates and why they were made. A culture of continuous improvement keeps your operations manual up-to-date and effective. ### Additional practices - **Onboarding integration**: Link the manual to your employee onboarding. - **Regulatory compliance**: Tag procedures related to compliance for easy auditing. - **Searchable content**: Ensure the manual is easily searchable. - **Mobile compatibility**: Test procedures on mobile devices. - **Feedback loops**: Provide ways for users to suggest improvements. By following these guidelines and using Tallyfy, you can build an operations manual that actively supports how your business runs. - **[How to avoid task debt](https://tallyfy.com/products/pro/tutorials/how-to/how-to-avoid-task-debt/)**: Expiring tasks auto-complete at deadlines to prevent incomplete work from piling up while smart workflow design with bundled tasks and realistic deadlines helps teams avoid the cascading stress of growing to-do lists. ## Preventing task debt in your workflows ![Task debt visualized as an overflowing inbox with papers flying out and piling up on the left, transforming to an organized desk with completed checkmarks on the right - representing workflow design that prevents task accumulation](https://screenshots.tallyfy.com/illustrations/task-debt.jpeg) Task debt happens when incomplete tasks accumulate faster than your team can complete them. Like technical debt in software development, task debt compounds over time - making it harder to focus on important work, creating stress, and ultimately reducing productivity. The solution isn't just working harder. It's about designing smarter workflows that prevent task buildup in the first place. ### Understanding task debt Task debt occurs when you keep moving incomplete tasks from one to-do list to the next. Every overdue item starts feeling like a priority, making it harder to distinguish what actually matters. This creates a cascading effect where: - Mental bandwidth gets consumed by tracking incomplete work - Team members feel overwhelmed by growing task lists - Important work gets lost in the noise of overdue items - Productivity drops as people spend more time managing tasks than completing them Research shows that task debt doesn't just affect task completion - it impacts creativity, decision-making quality, and workplace wellbeing. The longer tasks remain incomplete, the heavier they weigh on your mind, creating underlying anxiety whether you're consciously aware of it or not. ### Using expiring tasks for information sharing One of the most effective ways to prevent task debt is using [expiring tasks](/products/pro/tracking-and-tasks/tasks/what-types-of-tasks-can-i-create-with-tallyfy/) - a unique Tallyfy feature that auto-completes tasks at their deadline if not done manually. Think of it like the famous scene in Mission Impossible where the message says "This message will self-destruct in 5 seconds." An expiring task works the same way - if nobody acknowledges it by the deadline, it automatically completes itself. Expiring tasks work brilliantly for sharing information that's helpful but not critical. Instead of creating traditional tasks that pile up when people don't complete them, you can: - Share weekly updates that team members can review if they have time - Distribute FYI notifications that don't require action - Send optional training materials or resources - Provide status reports that are informative but not mandatory - Share non-critical announcements or reminders The key insight: expiring tasks let you share information through the task system without creating debt. Team members get notified, can engage if they want, but the task won't sit there forever if they don't. At the deadline, it simply marks itself complete and disappears from the overdue list. This approach respects that not everything needs active completion. Sometimes you just need to make information available without creating another item on someone's endless to-do list. ### Strategic task design Beyond expiring tasks, you can prevent task debt through thoughtful workflow design: **Bundle related work**. Instead of creating ten separate approval tasks, combine them into one complete review task with multiple [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/). This reduces the psychological burden of seeing numerous incomplete items. **Set realistic deadlines**. Tasks with impossibly short deadlines immediately become overdue, contributing to debt. Build buffer time into your deadlines based on actual completion patterns, not optimistic estimates. **Eliminate low-value tasks**. Audit your [templates](/products/pro/documenting/templates/) regularly. Remove tasks that don't directly contribute to outcomes. If a task consistently gets skipped or delayed without consequences, it probably shouldn't exist. **Use conditional logic**. Configure [automations](/products/pro/documenting/templates/automations/) to only create tasks when truly needed. Skip approval steps for low-risk items. Route work based on actual requirements, not worst-case scenarios. ### Smart assignment strategies How you assign tasks significantly impacts debt accumulation: **Workload balancing**. Before assigning tasks, check existing workloads. Tallyfy's [tracker view](/products/pro/tracking-and-tasks/tracker-view/) shows who has what on their plate. Distribute work evenly rather than overloading specific individuals. **Job title assignments**. Use [job titles](/products/pro/documenting/templates/edit-templates/understanding-assignment-types/) rather than specific people for routine tasks. This automatically distributes work and prevents bottlenecks when individuals are unavailable. **Group assignments with Take Over**. For tasks that need one person from a group, assign to the group and let someone take ownership using the Take Over feature. This prevents tasks from sitting unowned while multiple people assume someone else will handle it. ### Managing existing task debt If you already have task debt, here's how to dig out: 1. **Apply the two-minute rule**. Scan your overdue tasks. Complete anything that takes less than two minutes immediately. This quickly reduces the visible debt. 2. **Batch similar tasks**. Group related overdue items and handle them together. Processing ten expense reports at once is more efficient than doing them sporadically. 3. **Convert to expiring tasks**. For informational items that keep getting pushed, convert them to expiring tasks. They'll auto-complete at deadline, clearing your backlog. 4. **Cut ruthlessly**. Some tasks simply won't get done. Rather than letting them linger forever, make the decision to cancel them. Document why if needed, then move on. 5. **Renegotiate deadlines**. For tasks that matter but can't be done immediately, set new, realistic deadlines. This removes them from the overdue list while maintaining accountability. ### Creating sustainable workflows Long-term task debt prevention requires building sustainability into your workflows: **Regular reviews**. Schedule monthly reviews of your task completion rates. If certain tasks consistently go overdue, either eliminate them, extend their deadlines, or convert them to expiring tasks. **Feedback loops**. Encourage team members to report when tasks don't add value. They're closest to the work and can identify unnecessary steps. **Process metrics**. Use [Tallyfy Analytics](/products/pro/integrations/analytics/) to track task completion patterns. Look for bottlenecks and recurring delays. Address root causes rather than symptoms. **Cultural shift**. Move from "complete everything" to "complete what matters". Not every task deserves equal priority. Some information just needs to be available, not actively consumed. ### Implementing expiring tasks effectively To use expiring tasks for maximum benefit: 1. Navigate to your [template editor](/products/pro/documenting/templates/edit-templates/) 2. When adding or editing a step, select "Expiring" as the task type 3. Set a reasonable deadline that gives people time to review if they choose 4. Write clear descriptions explaining this is optional/informational 5. Use descriptive task names like "FYI: Weekly metrics update" or "Optional: Training video available" Remember - expiring tasks still trigger notifications, so assignees know the information is available. They just don't create permanent debt if ignored. - **[Improve processes effectively](https://tallyfy.com/products/pro/tutorials/how-to/improve-processes-effectively/)**: Tallyfy enables continuous process improvement by collecting team and customer feedback analyzing performance bottlenecks deploying instant template updates and implementing incremental changes while balancing standardization with flexibility to optimize workflows and enhance customer satisfaction. ## Process improvement in Tallyfy ![Process improvement visualized as a workflow diagram on the left being refined and optimized with upward trending metrics on the right - representing continuous enhancement through feedback, analytics, and iteration](https://screenshots.tallyfy.com/illustrations/improve-processes.jpeg) Tallyfy provides tools for ongoing process improvement through team feedback, analytics, and instant template updates. ### Collect improvement ideas from teams Team members doing daily tasks provide valuable improvement insights: - **Improvement comments**: Use Tallyfy's [built-in comments](/products/pro/tracking-and-tasks/tasks/how-to-report-and-resolve-issues-in-tallyfy/) to get ideas directly within specific process steps. - **Structured feedback**: Add feedback steps at the end of [processes](/products/pro/tracking-and-tasks/processes/) to regularly collect suggestions. - **Anonymous submissions**: Consider allowing anonymous feedback for more honest input. - **Idea voting**: Let team members upvote suggestions they like. :::tip[Using contextual feedback] Tallyfy's comments let team members suggest improvements directly on specific tasks. This provides context on where and how processes can be improved, better than general feedback. ::: ### Use customer feedback for improvements - **Customer satisfaction surveys**: Collect feedback at key points in the customer journey. - **Service quality metrics**: Track numbers like Net Promoter Score (NPS) or Customer Effort Score (CES). - **Support ticket analysis**: Look for patterns in customer issues that point to process problems. - **Direct customer interviews**: Talk to key customers about their experiences. When looking at customer feedback, focus on finding the root causes in the process. For example, late deliveries might signal issues in scheduling or fulfillment processes. ### Find bottlenecks with analytics - **Process duration analysis**: Use Tallyfy [Analytics](/products/pro/integrations/analytics/) to see which steps take longer than planned. - **Bottleneck identification**: Find steps where work often gets stuck or delayed. - **Completion rate tracking**: Monitor processes with low completion or high drop-off rates. - **Assignment analysis**: Identify overloaded team members who might be slowing things down. Tallyfy's [analytics features](/products/pro/integrations/analytics/) show how processes are performing, helping you find exact areas to improve. ### Communicate the purpose of changes - **Clearly state the problem**: Define the issue the process change is meant to fix. - **Explain the impact**: Communicate how the current process affects customers, team members, or results. - **Share the vision**: Describe how the improved process will lead to better outcomes. - **Connect to values**: Link the change to company values or strategic goals. As noted by experts like John Kotter, creating urgency and a clear vision are key first steps. :::note[Change management basics] When changing processes, consider using frameworks like Kotter's 8-Step Model or ADKAR (Awareness, Desire, Knowledge, Ability, Reinforcement). These structured methods can increase the chances of success. ::: ### Deploy changes instantly Tallyfy's template system supports making improvements step-by-step: - **Immediate updates**: Changes to [templates](/products/pro/documenting/templates/) apply instantly; no complex versioning. - **Updates go live instantly**: The next process launched automatically uses the newest template version. - **Continuous improvement**: Make small changes anytime without scheduled update windows. - **Simplified management**: Avoid managing many different versions of the same process. ### Make incremental improvements - **Start small**: Focus on minor improvements instead of huge overhauls. - **Compound benefits**: Small improvements build on each other, creating big results over time. - **Reduce resistance**: Smaller changes usually face less pushback. - **Learn continuously**: Use each small change as a chance to learn for future improvements. As James Clear writes in "Atomic Habits," small improvements add up significantly: getting 1% better daily leads to being 37 times better in a year. This applies to process improvement too. ### Process improvement vs automation - **Process improvement**: Making human tasks better by removing wasted effort, clarifying steps, or simplifying. - **Process automation**: Taking people out of the loop entirely using tools like [Robotic Process Automation (RPA)](/products/pro/integrations/open-api/how-does-tallyfy-combine-rpa-systems-and-human-operators/) or [API](/products/pro/integrations/open-api/) integrations. - **Hybrid approaches**: [Automating](/products/pro/documenting/templates/automations/) routine parts while improving the steps still done by people. When looking at a process step, ask these questions to decide the best way forward: 1. Can we eliminate this step completely? 2. If not, can we automate it with technology? 3. If people must do it, how can we make the step more efficient and less prone to errors? :::tip[Identifying automation candidates] Good steps to consider for full automation usually are: - Based on clear rules with specific criteria. - Done very often or in large volumes. - Repetitive with little variation. - Don't require much judgment. - Use structured data (clear inputs and outputs). ::: ### Measure customer impact - **Customer journey mapping**: See how process changes affect the customer's overall experience. - **Outcome metrics**: Track customer-focused numbers like satisfaction, retention, or referrals. - **Value stream analysis**: Check how changes affect activities that create customer value. - **Customer feedback loops**: Ask customers for feedback specifically about process changes. ### Structured improvement methods - **Lean**: Focus on removing wasted effort and maximizing value. - **Six Sigma**: Reduce differences and errors using data analysis. - **Kaizen**: Focus on small, ongoing improvements. - **PDCA (Plan-Do-Check-Act)**: Test changes in small batches before rolling them out fully. Many organizations mix elements from different methods. ### Document improvements - **Update process documentation**: Make sure Tallyfy templates reflect the improved processes. - **Record lessons learned**: Write down what worked, what didn't, and why. - **Share success stories**: Tell others in the company about improvements and their results. - **Create improvement patterns**: Identify successful approaches that could work for other processes. ### Balance standardization with flexibility - **Standardize the core**: Make the main parts of a process standard to ensure quality and compliance. - **Allow contextual variation**: Give teams flexibility to adapt to unique situations where appropriate. - **Define decision parameters**: Clarify where judgment is okay and where standards must be followed strictly. - **Review exceptions**: Monitor when standard processes are bypassed to find opportunities for improvement. ### Additional improvement strategies - **Process mining**: Use special tools to find out how processes actually run based on system data. - **Cross-functional teams**: Get input from different people when designing improvements. - **Pilot testing**: Test big changes on a small scale before full rollout. - **Regular review cycles**: Schedule regular process reviews instead of waiting for problems. - **Training and communication**: Make sure teams understand and can perform improved processes. - **Recognition programs**: Acknowledge team members who suggest good improvements. - **[Merge templates](https://tallyfy.com/products/pro/tutorials/how-to/how-to-merge-two-process-templates/)**: Tallyfy users can merge two procedure templates by exporting them as documents using AI tools to combine the content and then importing the merged result back into Tallyfy as a new template through document upload functionality. Tallyfy workflow management doesn't offer a direct feature to merge two existing [procedure templates](/products/pro/documenting/templates/) into a single one. However, you can achieve a similar result by using external AI tools and Tallyfy's document import capabilities. This guide outlines a manual workaround approach. ## What are the prerequisites for merging templates? - You have two existing [procedure templates](/products/pro/documenting/templates/) in Tallyfy that you want to merge. - Access to an AI content generation tool (e.g., ChatGPT, Google Gemini, Claude). - Ability to convert text or markdown from the AI tool into a Microsoft Word (`.docx`) or PDF (`.pdf`) file. ## What are the steps to merge two templates? First, you need to get the content of both [procedure templates](/products/pro/documenting/templates/) out of Tallyfy. You can do this by exporting them as PDF documents, or by printing them which can often be saved as a Word document. Refer to the guide on how to [Print, download, and export Tallyfy templates](/products/pro/documenting/templates/print-download-export-templates/) for detailed instructions on getting your templates into a document format. You will need one document for each template. Once you have both templates as separate documents (e.g., two PDF or Word files), you can use your preferred AI tool to combine them. Upload both documents to the AI tool and provide a prompt similar to this: ```text I use Tallyfy - which helps me create and run process templates. I have two process templates which I need you to combine into a single one. Both of the process templates are attached as documents. Make sure you keep all details within both without losing any details. You should start by identifying the commonalities first and then adding the differences between the first and second into the single output or result. The end result should be a set of process steps which combines both of these without losing the detail present within each one, including descriptions of how to do steps. I intend to import this final result into Tallyfy to create my template there. ``` Review the output from the AI tool carefully to ensure it has accurately merged the steps and details from both original templates. The AI tool will likely provide the merged process in a text or markdown format. Before you can import this into Tallyfy, you\'ll need to convert this output into a Microsoft Word (`.docx`) or PDF (`.pdf`) file. You can use various online converters or word processing software for this conversion. With your merged process now in a Word or PDF file, you can create a new [template](/products/pro/documenting/templates/) in Tallyfy by uploading this file. Follow the instructions in the "Create a template by uploading an existing document" section of the [Create a template](/products/pro/documenting/templates/create-template/) article. Tallyfy's AI will analyze your uploaded document and attempt to convert it into a new Tallyfy template. :::note[Review and refine] After importing, carefully review the newly created template in Tallyfy. You may need to adjust steps, formatting, assignments, or add [automations](/products/pro/documenting/templates/automations/) as Tallyfy's AI interpretation of the uploaded document might not be perfect. ::: This workaround provides a way to combine the content of two templates. However, it requires manual steps and careful review throughout the process. - **[Improve accountability](https://tallyfy.com/products/pro/tutorials/how-to/make-people-accountable-for-tasks/)**: Tallyfy enhances task accountability through transparent workflows automatic reminders manual nudges for urgent tasks single-person ownership via Take Over features comment-based discussions blocker documentation clear instructions task expiration policies escalation paths and balanced recognition systems that prevent task debt while maintaining team productivity. ## Task accountability in Tallyfy ![Accountability visualized as tasks being passed like hot potatoes on the left transforming to clear ownership with a person confidently holding a task on the right](https://screenshots.tallyfy.com/illustrations/accountability.jpeg) Tallyfy provides features to make accountability clear and lasting. ### Transparent workflows Making task status visible increases accountability: - **Public task status**: Tallyfy's dashboard shows who is responsible for active tasks and their current status. - **Progress tracking**: Visuals highlight where processes are stuck and who is responsible. - **Timeline views**: History shows when tasks were assigned, started, and completed. - **Activity tracking**: The system automatically logs actions taken on tasks. Transparency encourages timely completion without direct intervention. ### Automatic reminders Automated reminders ensure consistent follow-up: - **Daily digest emails**: The system sends personalized notifications about pending tasks. - **Customizable frequency**: Users can set their preferred [reminder schedule](/products/pro/settings/personal-settings/how-can-i-manage-email-notifications-in-tallyfy/). - **Set-and-forget**: Once set up, reminders work automatically for all tasks. - **Prioritization**: Reminders highlight overdue tasks and upcoming deadlines. Automation eliminates manual follow-up and builds accountability into daily work. ### Manual reminders for urgent tasks For time-sensitive tasks, you can give extra nudges: - **Instant email reminders**: [Send immediate notifications](/products/pro/tracking-and-tasks/tasks/how-can-i-send-email-reminders-in-tallyfy/) to all assignees with one click. - **Custom reminder messages**: Add personal notes to stress urgency or add context. - **Scheduled follow-ups**: Set calendar reminders to check task progress. - **Sequential escalation**: Follow a consistent pattern (e.g., reminder -> direct message -> manager involvement). Reserve manual nudges for urgent situations. ### Single-person ownership with "Take Over" The Take Over feature clarifies responsibility when multiple people are assigned: - **Take Over feature**: Tallyfy lets a team member take full ownership of a task. - **Clear assignment**: When someone takes over, others are removed, making responsibility clear. - **Voluntary commitment**: Choosing to take over encourages personal ownership. - **Documented handoffs**: The system logs who took responsibility and when. This converts group tasks into individual responsibility. :::note[When to use the 'Take Over' feature] The Take Over feature is helpful for tasks that: 1. Need one person to make a decision, not group input. 2. Are stuck because ownership is unclear. 3. Need a single point of contact. 4. Benefit from one person being clearly responsible. ::: ### Comments for accountability Use comments for accountability discussions: - **Contextual questions**: Ask about task status directly in the task's comments. - **@mentions**: Tag specific people to ensure they see your comment. - **Default comments**: Use standard comment templates for consistent check-ins. - **Comment history**: Keep a documented record of accountability talks. - **Email notifications**: Comments automatically trigger email alerts. Comments stay focused on specific tasks rather than general performance. ### Documenting blockers When tasks are blocked: - **Blocking comments**: Team members can mark comments as blockers, showing what's stopping progress. - **Visibility of blockers**: These comments are clearly displayed, showing why a task is delayed. - **Shared problem-solving**: Transparency helps teams solve problems together. - **Accountability transfer**: Responsibility can shift to fixing the blocker when needed. This distinguishes between avoidance and genuine blockers. ### Clear task instructions Clear instructions improve task completion: - **Specific instructions**: Include step-by-step guidance. - **Defined success criteria**: Explain what 'done' looks like. - **Resource links**: Provide links to needed info, tools, or templates. - **Supporting documentation**: Attach examples or training materials. ### Task expiration policies Configure tasks to auto-complete after deadlines to prevent [task debt](/products/pro/tutorials/how-to/how-to-avoid-task-debt/): - **Expiring task types**: Set up certain tasks to auto-complete after their deadline, perfect for FYI and informational items. - **Time-based auto-completion**: Create rules for tasks to close automatically after a set time. - **Clear expectations**: Tell your team about these policies so they know the consequences of inaction. - **Task prioritization**: Helps separate critical tasks from nice-to-haves. - **Information sharing without debt**: Use [expiring tasks](/products/pro/tracking-and-tasks/tasks/what-types-of-tasks-can-i-create-with-tallyfy/) to share updates, resources, or optional content without creating permanent backlog. This prevents task buildup and creates urgency for truly important items while allowing information sharing without accumulating debt. ### Escalation paths Structure escalation for accountability issues: - **Sequential escalation**: Follow a consistent pattern (e.g., reminder -> comment -> manager added). - **Manager involvement**: Add supervisors as assignees if first steps aren't enough. - **Pattern recognition**: Track recurring issues to find and fix root causes. - **Performance connections**: Connect consistent task completion (or lack thereof) to performance reviews. ### Balanced accountability culture Balance accountability with support: - **Recognition systems**: Acknowledge people who consistently complete tasks. - **Constructive approach**: Focus conversations on solving problems, not blaming. - **Skill development**: Offer training for those struggling with tasks. - **Reciprocal accountability**: Make managers responsible for providing support and removing obstacles. ### Additional strategies - **Start with why**: Explain the task's purpose and impact. - **Manage workloads**: Ensure task loads are reasonable. - **Time blocking**: Encourage scheduling specific time for tasks. - **Peer accountability partnerships**: Set up ways for teammates to check in. - **Breaking down tasks**: Divide big responsibilities into smaller tasks. - **Success celebration**: Recognize consistent completion to encourage the behavior. - **[Complex approval workflows](https://tallyfy.com/products/pro/tutorials/how-to/track-and-run-complex-approval-workflows/)**: Multi-level approval workflows can be transformed from chaotic unclear processes into trackable systems using structured kick-off forms with validation rules and breaking down complex approvals into sequential or parallel steps with conditional visibility and dynamic assignments based on criteria like purchase amount or category while maintaining real-time status tracking through dashboards and automated reminders to keep approvals moving forward. ## Transforming multi-level approvals into trackable processes Complex approval workflows can cause slowdowns, with people unsure about status, requirements, or next steps. Tallyfy helps turn these into trackable workflows with clear visibility and accountability. ### Design kick-off forms Start approval workflows with the right information: - **Identify critical initial data**: Figure out what information is needed before approval can start. - **Create a concise kick-off form**: Design a [form with only essential fields](/products/pro/tutorials/how-to/build-effective-forms/) to make it easier to submit. - **Use appropriate field types**: Choose the right [form field types](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) (e.g., dropdowns, file uploads). - **Include field guidance**: Add instructions explaining what info is needed. - **Consider validation rules**: Use [field validation](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/#short-text-field) to ensure data quality. :::tip[Auto-creating from existing documents] If your approval workflow is already in a document, Tallyfy can often convert it into a template automatically. Upload the document, and it will try to extract steps. ::: ### Break down approval steps Divide complex approvals into separate steps: - **Map the full process**: Identify every required step from start to finish. - **Define the approval sequence**: Set the order for approvals. - **Identify stakeholders**: Determine who needs to approve or give input at each stage. - **Document policy requirements**: Include company policies in step instructions. - **Consider parallel and sequential approvals**: Decide which steps can happen at the same time and which must follow an order. Each step in Tallyfy can be a standard task or an [approve/reject task](/products/pro/tracking-and-tasks/tasks/what-types-of-tasks-can-i-create-with-tallyfy/#approvereject) with clear action buttons. ### Approval workflow visualization This diagram shows how a typical purchase approval process flows through various decision points and assignments. [Diagram removed for brevity] **What to notice:** - High-value purchases (≥$10,000) automatically trigger additional CFO approval, ensuring financial oversight - The system routes reviews to specialists based on purchase category - software goes to Jane Doe for privacy review - Overdue tasks trigger automated reminders (shown with dotted lines) without manual intervention ### Implement conditional visibility Not all steps apply in every situation. Use rules to show only relevant tasks: - **Identify decision points**: Find where the process might split based on conditions. - **Create "if-this-then-that" rules**: Use [Tallyfy's automation](/products/pro/documenting/templates/automations/) to set up logic. - **Set visibility conditions**: Use [visibility actions](/products/pro/documenting/templates/automations/actions/visibility-actions/) to show/hide steps based on conditions. - **Create dynamic approval paths**: Ensure approvers only see relevant tasks. For example: ``` IF (Purchase Amount) is greater than $10,000 THEN SHOW "CFO Approval" ``` This ensures people only see tasks relevant to the specific approval situation. ### Configure dynamic assignments Automatically send tasks to the right approvers: - **Identify role-based assignments**: Decide which roles handle each step. - **Create variable assignments**: Use [assignment actions](/products/pro/documenting/templates/automations/actions/asignment-actions/) to assign tasks based on form answers. - **Implement conditional routing**: Send approvals to different people based on department, amount, etc. - **Set up backup assignments**: Assign to groups or multiple people to cover absences. For example: ``` IF (Purchase Category) is "Software" THEN assign "Vendor Privacy Review" to "Jane Doe" ``` Dynamic assignment sends requests to the right experts without needing someone to route manually. ### Track approval status in real-time - **Central tracking dashboard**: Monitor all approvals in the [Tracker view](/products/pro/tracking-and-tasks/tracker-view/how-can-i-manage-and-track-my-processes-on-tallyfy/). - **Real-time status updates**: See which step is active and who is responsible. - **Deadline monitoring**: Track upcoming and overdue approvals (color-coded). - **Progress visualization**: View completion percentage and remaining steps. - **Detailed activity logs**: Access [history](/products/pro/tracking-and-tasks/tracker-view/how-can-i-track-process-activities-on-tallyfy/) showing every action. This avoids many status questions and gives everyone visibility. ### Set up automated reminders Keep approvals moving with automatic follow-up: - **Scheduled email digests**: Set up [automatic reminders](/products/pro/tracking-and-tasks/tasks/how-can-i-send-email-reminders-in-tallyfy/) for pending tasks. - **Escalation pathways**: Create [automation rules](/products/pro/documenting/templates/automations/actions/status-actions/) to notify managers about delays. - **Custom notification schedules**: Let users adjust [reminder frequency](/products/pro/settings/personal-settings/how-can-i-manage-email-notifications-in-tallyfy/) (within limits). - **Manual reminder options**: Allow process owners to send [immediate reminders](/products/pro/tracking-and-tasks/tasks/how-can-i-send-email-reminders-in-tallyfy/#sending-manual-ad-hoc-reminders) for urgent items. This system ensures approvals don't get stuck because of missed emails or busy schedules. ### Enable workflow communication Approvals often need more info or discussion. Tallyfy's comments keep this communication organized: - **Step-specific comments**: Ask questions or give feedback directly on approval steps. - **\@mentions**: Tag people in comments to get their attention. - **Embedded context**: Reduces the need to re-explain the situation with every question. - **Conditional approvals**: Allows for more detailed responses like "Approved if you provide X". - **Comment history**: Keeps a record of discussions. This turns simple yes/no decisions into collaborative problem-solving, keeping things moving. ### Organize and archive approvals Keep records organized and easy to find: - **Tagging system**: Have submitters [tag or categorize](/products/pro/documenting/templates/how-to-manage-templates-and-processes-with-tags/) requests. - **Folder organization**: Automatically file completed approvals into the right [folders](/products/pro/tracking-and-tasks/tracker-view/organize-processes/). - **Searchable archives**: Find past approvals easily using search and filters. - **Data extraction**: [Export approval data](/products/pro/tracking-and-tasks/processes/how-can-i-export-tallyfy-processes-to-csv/) for reporting. - **Retention policies**: Set up organized archiving based on company rules. This keeps completed approvals accessible for audits or analysis while keeping active views clean. ### Beyond flowcharts Traditional flowcharts don't handle human judgment, exceptions, or communication well: - **Human-centered design**: Build workflows that handle complex decisions. - **Flexible pathways**: Allow for differences and exceptions. - **Continuous improvement**: Learn from each approval to improve the process. - **Contextual collaboration**: Support the discussion needed for approvals. - **Adaptable framework**: Create processes that can change with the organization. Tallyfy treats complex approvals as collaborative human processes, not just requests being sent around. ### Best practices - **Start simple**: Begin with core steps and add complexity slowly as needed. - **Involve stakeholders**: Get input from approvers when designing. - **Test**: Run pilot approvals small-scale first. - **Document guidelines**: Create clear criteria for approval decisions. - **Review regularly**: Analyze completed approvals to find improvements. - **Train participants**: Make sure everyone understands the system. - **Measure performance**: Track metrics like approval time and bottlenecks. [Try Tallyfy now](https://tallyfy.com/start/) or [schedule a call](https://tallyfy.com/booking/) to discuss your specific challenges. - **[Track time on tasks](https://tallyfy.com/products/pro/tutorials/how-to/track-time-in-tasks/)**: This guide explains how to implement time tracking in Tallyfy workflows by adding number fields to tasks with validation rules to capture hours and minutes spent on each task for accurate measurement and cost analysis. ## Implementing time tracking in Tallyfy workflows You can track time in Tallyfy by adding number fields to tasks with validation rules. This creates a simple time tracking system that captures hours and minutes spent on each task, enabling accurate workflow measurement and cost analysis. Time tracking helps measure task duration, calculate project costs, identify process bottlenecks, and improve resource allocation. Here's how to implement it effectively. ### Prerequisites - Administrator or Standard user role - Access to edit [templates](/products/pro/documenting/templates/) - Basic understanding of [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) ### When to use time tracking Time tracking works best for: - Billable client work requiring accurate hour logs - Process improvement initiatives measuring task efficiency - Compliance requirements mandating time documentation - Resource planning based on actual task duration - Cost analysis for specific workflow steps ## Steps to implement time tracking ## Advanced time tracking configurations ### Using variables to calculate total time While Tallyfy doesn't automatically calculate totals, you can use [variables](/products/pro/documenting/templates/variables/) to display entered time in subsequent tasks: 1. In a later task description, insert variables: `{{Hours spent on this task}} hours and {{Minutes spent on this task}} minutes were logged` 2. This creates visibility of time spent for approvers or reviewers ### Setting up time-based automations Use [automation rules](/products/pro/documenting/templates/automations/) to trigger actions based on time entries: - **Example**: If hours spent > 8, assign task to manager for review - **Example**: If total time exceeds budget, send notification email ### Implementing project-wide time tracking For complete time tracking across an entire process: 1. Add time fields to every task requiring measurement 2. Create a summary task at the end titled "Time Tracking Summary" 3. Use the task description to list all time variables from previous tasks 4. Export data via [CSV](/products/pro/tracking-and-tasks/processes/how-can-i-export-tallyfy-processes-to-csv/) for analysis ## Important considerations for accurate time tracking ### The reality of workplace time tracking Getting accurate time data is harder than it seems. Here's why - and what you can do about it: **Multi-tasking makes tracking difficult** People rarely work on one task at a time. Your team member might spend 30 minutes on a task, get pulled into a meeting, answer three urgent emails, then return to finish the task an hour later. Did that task take 30 minutes or 90 minutes? Both answers have merit. **Holidays and absences skew averages** When calculating how long tasks typically take, holidays and vacation days throw off your numbers. A task assigned on December 23rd might sit untouched until January 2nd. That's not a 10-day task - it's a 2-hour task with an 8-day holiday in the middle. **External delays aren't the assignee's fault** Sometimes tasks stall for reasons beyond anyone's control. Waiting for client feedback, dependencies on other delayed tasks, or system outages all add time that has nothing to do with how long the actual work takes. ### The clean solution: Ask for time input The most reliable approach? Add a form field asking assignees to record their actual working time. Yes, it's one more field to fill out - but it gives you honest, clean data about how long tasks really take. Here's why this works: - People know exactly how much time they spent on the task (not the elapsed time) - You capture actual effort, not calendar time - External delays don't contaminate your data - You can still track elapsed time separately through Tallyfy's built-in timestamps ### Analytics timestamps inherit these challenges **Important**: The timestamps in Tallyfy Analytics and CSV exports measure elapsed time between task assignment and completion. They're subject to all the issues above - multi-tasking, holidays, external delays. That "3-day average" might actually represent 30 minutes of work spread across a long weekend. Always interpret timestamp data with this context in mind, or better yet, implement effort tracking fields for cleaner metrics. ## Best practices for time tracking ### Field naming conventions Use consistent naming for easy reporting: - "Task Name - Hours" - "Task Name - Minutes" - This makes CSV exports more readable ### Setting realistic limits - Set maximum hours based on typical task duration - Use validation to prevent data entry errors - Consider using dropdown lists for standard time increments ### Training your team - Add guidance text explaining time tracking expectations - Specify whether to track active work time only or total elapsed time - Clarify if breaks should be included or excluded - Explain the difference between effort time and elapsed time ### Regular time analysis - Export process data monthly to analyze time trends - Identify tasks consistently taking longer than expected - Use insights to optimize workflow design - Consider both effort metrics and elapsed time when analyzing bottlenecks ## Common time tracking scenarios ### Billable hours tracking For client billing, consider: - Adding a "Billable?" radio button field (Yes/No) - Including a "Billing Code" dropdown field - Creating separate fields for billable vs non-billable time ### Compliance time logs For regulatory requirements: - Make all time fields required - Add timestamp validation to ensure accuracy - Include additional fields for: - Start time - End time - Break duration - Reason for delays ### Performance metrics To measure efficiency: - Track both estimated and actual time - Add fields for "Estimated Hours" and "Estimated Minutes" - Compare estimates to actuals in your analysis ## Extracting time tracking data ### Manual CSV export 1. Open any running process with time tracking 2. Click **Settings** > **Export CSV** 3. Open in Excel/Google Sheets 4. Sum time columns for total duration ### Automated reporting via API Use the [Tallyfy API](/products/pro/integrations/open-api/) to: - Pull time data into business intelligence tools - Create automated time reports - Integrate with billing systems ### Real-time notifications Configure [webhooks](/products/pro/integrations/webhooks/) to: - Alert when time exceeds thresholds - Send daily time summaries - Trigger billing system updates ## Troubleshooting time tracking ### Common issues and solutions **Problem**: Users entering time in wrong format **Solution**: Use dropdown fields with preset time options instead of text entry **Problem**: Forgetting to track time **Solution**: Make time fields required and add reminder text **Problem**: Time entries seem inaccurate **Solution**: Add "Time Entry Method" field with options like "Timer", "Estimate", "Calculated" **Problem**: Different time zones causing confusion **Solution**: Add timezone field or standardize on UTC - **[Process improvement](https://tallyfy.com/products/pro/tutorials/how-to/process-improvement/)**: Tallyfy provides a structured approach to process improvement that covers fundamental concepts like DMAIC and Lean principles along with practical techniques for identifying customer needs and eliminating waste in office workflows while using built-in analytics and AI-driven suggestions to help teams implement and sustain continuous improvements. ## How can I understand core concepts of process improvement? Improving Tallyfy business processes is crucial for any organization aiming to enhance efficiency, boost customer satisfaction, and maintain a competitive edge. For a broader perspective, see our guide on [continuous process improvement](https://tallyfy.com/continuous-process-improvement/). This guide explores various facets of process improvement, from foundational concepts to specific methodologies. All content is tailored to how you can use Tallyfy to achieve your goals. We will particularly focus on how these principles, often rooted in manufacturing, can be powerfully applied to office environments and professional services. Tallyfy empowers you to not only document but also actively manage and automate your processes. This creates a dynamic environment for continuous improvement. ## What will I find in this guide? This section provides a roadmap to understanding and implementing process improvement within your organization using Tallyfy. Explore the articles below to learn about: - The fundamentals of process improvement and its benefits. - Understanding and documenting your current processes with Tallyfy's unique approach. - Identifying what your customers truly value (Critical to Quality requirements). - Key improvement methodologies like DMAIC, Lean (waste elimination), and Kaizen (continuous small improvements) and how they apply in a modern office setting. - Practical techniques for gathering data, analyzing root causes, and generating effective solutions. - Using Tallyfy's specific features, such as contextual comments, AI-driven suggestions, and real-time analytics, to accelerate improvement. - Streamlining change management and building a sustainable culture of continuous improvement. Explore the articles below to start your journey towards more efficient and effective operations with Tallyfy. ### Process improvement - **[Build a culture of continuous improvement](https://tallyfy.com/products/pro/tutorials/how-to/process-improvement/building-a-culture-of-continuous-improvement/)**: Building a continuous improvement culture requires leadership commitment and employee empowerment where Tallyfy supports this through transparent process documentation in-task commenting for frontline suggestions standardized templates as improvement baselines analytics for data-driven decisions and easy template updates that enable rapid iteration and learning. ## How can I cultivate continuous enhancement within my team? True Tallyfy process mastery isn't achieved through isolated improvement projects alone. It's cultivated by fostering a **culture of continuous improvement (CI)**. This represents a mindset and a set of practices where everyone in the organization is empowered and encouraged to proactively seek out and implement ways to make processes better, every day. Tallyfy provides a powerful platform to help build and sustain such a culture. ### What is a culture of continuous improvement? A CI culture means that improvement is not just an occasional initiative but is woven into the fabric of daily operations. This culture is characterized by: - **Leadership Commitment**: Leaders actively champion CI, model desired behaviors, and remove barriers to improvement. - **Employee Empowerment & Involvement**: Everyone, especially those closest to the work, feels responsible for and capable of suggesting and making improvements. - **Open Communication & Feedback**: Ideas and constructive criticism are welcomed and discussed openly. - **Learning from Experience**: Both successes and mistakes are seen as learning opportunities, recognizing that traditional training [fails due to memory limitations](/products/pro/tutorials/why-documentation-training-fails-forgetting-curve/). - **Celebrating Progress**: Recognizing and celebrating improvements, big or small, reinforces positive behaviors. - **Standardized Processes as a Foundation**: Clear, standard processes (like those in Tallyfy) provide the baseline from which to improve. - **Data-Driven Decisions**: Improvements are based on facts and data, not just gut feelings. This aligns closely with the [Kaizen philosophy](/products/pro/tutorials/how-to/process-improvement/kaizen-making-continuous-small-improvements-with-tallyfy/) of small, ongoing changes driven by everyone. ### Why should I strive for a continuous improvement culture? Organizations that successfully cultivate a CI culture reap significant long-term rewards: - **Sustained Success**: Improvements are more likely to stick and compound over time. - **Greater Adaptability**: The organization becomes more agile and responsive to changing customer needs and market conditions. - **Increased Employee Engagement**: When employees have a voice and can see their ideas making a difference, their engagement and job satisfaction soar. - **Innovation**: A culture that encourages questioning and experimentation naturally breeds innovation. ### How does Tallyfy help build a CI culture? Tallyfy isn't just a process execution tool. Its features are designed to nurture a continuous improvement mindset: 1. **Empowers Bottom-Up Suggestions with Comments**: Tallyfy's [in-task comment feature](/products/pro/tracking-and-tasks/tasks/how-to-report-and-resolve-issues-in-tallyfy/) is a direct channel for anyone executing a process to flag issues or suggest improvements precisely when and where they notice them. This empowers employees and ensures valuable frontline insights are captured. 2. **Fosters Transparency and Shared Understanding**: With [Tallyfy templates](/products/pro/documenting/templates/), processes are no longer hidden in manuals or individual knowledge. They are visible to all relevant team members, promoting a shared understanding of how work gets done and where potential improvements lie. 3. **Provides a Stable Baseline with Standardized Templates**: CI requires a stable starting point. Tallyfy templates act as your standardized processes, ensuring everyone is working from the same playbook, making it easier to identify deviations and measure the impact of improvements. 4. **Supports Data-Driven Decisions with Analytics**: [Tallyfy Analytics](/products/pro/integrations/analytics/) provide objective data on process performance, helping teams identify areas for improvement based on facts rather than assumptions. 5. **Enables Rapid Iteration and Learning**: The ease with which Tallyfy [templates can be updated](/products/pro/documenting/templates/edit-templates/) and changes deployed instantly allows for quick implementation of small improvements. This rapid iteration cycle is crucial for a CI culture, as it allows teams to learn and adapt quickly. 6. **Lowers the Barrier to Process Documentation and Ownership**: Tallyfy's simplicity means that teams can easily document and take ownership of their own processes. This localized ownership is a key driver of CI, as those closest to the work are best positioned to improve it. :::tip[Leadership Role in a Tallyfy-Powered CI Culture] Leaders can actively foster this culture by: - Regularly reviewing process improvement suggestions made in Tallyfy comments. - Using Tallyfy to track and showcase improvement initiatives. - Publicly recognizing individuals and teams for their contributions to process enhancements. - Encouraging experimentation and learning, even if some small changes don't yield the expected results immediately. ::: *"Tallyfy provides the tools and transparency needed to make continuous improvement a daily reality, not just a slogan." Building a culture of continuous improvement is a journey, not a destination. By using Tallyfy's collaborative and transparent platform, you can empower your entire organization to participate in this journey. This transforms how you work and consistently delivers better outcomes. - **[Gather data and use Tallyfy Analytics](https://tallyfy.com/products/pro/tutorials/how-to/process-improvement/gathering-data-and-using-tallyfy-analytics-for-insights/)**: Data and analytics replace guesswork in process improvement by providing objective evidence to identify real problems establish performance baselines pinpoint bottlenecks and measure the impact of changes while tools like Tallyfy Analytics automatically capture workflow data including task completion times process duration and bottlenecks to enable proactive optimization through visualization and regular review. ## Use data and analytics to guide improvements Effective process improvement isn't about guesswork; it's about making informed decisions based on facts. Data provides these facts, helping you understand how your processes are truly performing, identify where the real problems lie, and measure the impact of any changes you make. ### Why data is essential for process improvement - **Manages by Fact**: Data replaces assumptions and opinions with objective evidence. - **Identifies Real Problems**: Helps distinguish symptoms from root causes. - **Baselines Performance**: You need to know where you are to measure how far you've come. - **Pinpoints Bottlenecks**: Shows where work gets stuck or takes too long. - **Measures Impact**: Validates whether improvements have had the desired effect. ### What data should you collect? For office and service processes, your data collection should align with your **Critical to Quality (CTQ)** requirements (what your customers value) and overall process performance. Consider two main types of measures: - **Output Measures (Y variables)**: These reflect the results or outcomes of your process. Examples include: - Customer satisfaction scores (e.g., NPS, CSAT) - Error rates or defect counts (e.g., number of incorrect invoices) - On-time delivery percentage - Total process completion time (cycle time) - **Process Measures (X variables)**: These are in-process metrics that can influence the output measures. Examples include: - Time taken for individual steps - Rework rates at specific points - Queue or waiting times between steps - Number of approvals required A simple **Data Collection Plan** can be helpful, even if it's just a basic checklist answering: What data to collect? Why is it important? How will it be collected? When/how often? Where in the process? Who is responsible? ### How Tallyfy helps gather process data Manually collecting process data can be time-consuming and prone to errors. Tallyfy simplifies this significantly with **[Tallyfy Analytics](/products/pro/integrations/analytics/)**, an add-on service where you connect your own BI tools to analyze workflow data. Tallyfy automatically captures a wealth of data as your processes run, including: - **Task Completion Times**: How long each step actually takes (based on timestamps - for actual effort time, see [how to track time spent on tasks](/products/pro/tutorials/how-to/track-time-in-tasks/)). - **Overall Process Duration**: The total end-to-end time for each instance of a process. - **User Workload and Performance**: Insights into how tasks are distributed and completed by team members. - **Overdue Tasks**: Highlights tasks and processes falling behind schedule. - **Step-by-Step Bottlenecks**: Identifies where work is consistently slowing down. ### Using Tallyfy Analytics to find improvement opportunities By regularly reviewing data from [Tallyfy Analytics](/products/pro/integrations/analytics/) in your own BI tools, you can gain actionable insights: - **Identify Bottlenecks**: Spot steps that consistently take longer than others. This is a prime area for investigation – why is this step slow? Can it be simplified, resourced differently, or automated? - **Track Cycle Times**: Monitor the average time it takes to complete entire processes. If cycle times are increasing or are highly variable, it signals a need for improvement. - **Monitor On-Time Completion**: See if processes and individual tasks are meeting their deadlines. High rates of overdue tasks point to issues with workload, complexity, or unrealistic deadlines. - **Understand Workload Distribution**: Identify if certain team members are consistently overloaded, which can lead to delays and burnout. This might suggest a need to reassign tasks or redesign parts of the process. :::tip[Be Proactive with Analytics] Don't wait for problems to become critical. Schedule regular reviews of your Tallyfy Analytics (e.g., weekly or monthly) to proactively identify emerging issues or opportunities for optimization. ::: ### Visualizing data for clearer insights Raw numbers can be hard to interpret. Visualizing data through charts and graphs makes trends, patterns, and outliers much clearer. Tallyfy Analytics lets you connect your preferred BI tools (like Tableau, Power BI, or Looker) to create custom visualizations. Understanding basic visualization concepts is helpful: - **Run Charts**: Plotting a metric (like task completion time) over time can reveal trends (is it getting better or worse?) or seasonal patterns. - **Pareto Charts**: Helps identify the "vital few" causes of a problem (e.g., the 20% of error types that cause 80% of the rework). Data from Tallyfy (e.g., a high number of tasks frequently getting stuck at one particular step, or numerous comments indicating confusion there) acts as a strong signal, pinpointing exactly where a process might need simplification, clearer instructions, additional resources, or a complete rethink. While Tallyfy provides significant out-of-the-box analytics, you can also export process data for more advanced analysis in other tools if your needs are highly specific. However, for most day-to-day process improvement in office environments, Tallyfy Analytics offers a powerful and accessible starting point. - **[Generate, test, and prioritize improvement ideas](https://tallyfy.com/products/pro/tutorials/how-to/process-improvement/generating-testing-and-prioritizing-improvement-ideas/)**: This content explains how to transform improvement ideas into actionable solutions by using creative ideation techniques like brainstorming and SCAMPER testing ideas through small-scale pilots and prioritizing solutions using impact-effort matrices to focus on the most valuable changes. ## How can I choose the right improvements from idea to impact? Once you've analyzed your process and identified root causes for problems (as discussed in [Simple root cause analysis techniques](/products/pro/tutorials/how-to/process-improvement/simple-root-cause-analysis-techniques/)), the next exciting step involves generating, testing, and prioritizing potential solutions. This is where creativity meets practicality to forge effective process improvements. ### How can I generate improvement ideas through ideation? Don't limit yourself to the first solution that comes to mind. Encourage a diverse range of ideas, even those that seem unconventional at first. - **Brainstorming**: This classic technique involves a group freely generating ideas without initial criticism. Encourage a high volume of suggestions. Variations include: - *Negative Brainstorming*: Ask, "How could we make this process even worse?" Then flip the answers to find positive solutions. - *Brainwriting*: Participants write down ideas individually before sharing with the group, ensuring quieter voices are heard. - **SCAMPER**: This acronym prompts structured creative thinking: - **S**ubstitute: What components, people, or rules can be replaced? - **C**ombine: Can you merge steps, roles, or objectives? - **A**dapt: What else is like this? What other ideas does it suggest? - **M**odify: Can you change an attribute, like size, shape, or frequency? - **P**ut to other uses: Can the process or parts of it be used differently? - **E**liminate: What can be removed or simplified? - **R**earrange/Reverse: Can you change the order of steps or do things in reverse? **Tallyfy for Idea Generation:** - Use a dedicated [Tallyfy template](/products/pro/documenting/templates/) for brainstorming. Each step can serve as a creative prompt, with team members adding ideas in [task comments](/products/pro/tracking-and-tasks/tasks/how-to-report-and-resolve-issues-in-tallyfy/) or dedicated [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/). - Mine existing Tallyfy comments on operational processes – they are often a goldmine of improvement suggestions directly from users. ### How can I test my ideas through piloting? Before committing to a full-scale rollout of an improvement, it's wise to test it on a smaller scale. This process is called piloting. - **Why Pilot?** Piloting helps to reduce risk, gather real-world feedback, validate assumptions, and refine the solution before wider implementation. - **Running a Simple Office Pilot**: For a process managed in Tallyfy, piloting can be as straightforward as: 1. Copying the existing Tallyfy template. 2. Modifying the copied template with the proposed improvement. 3. Assigning this pilot template to a small, representative group of users or for a limited number of cases/time period. 4. Clearly defining what you will measure to assess the pilot's success (e.g., time reduction, error rate, user feedback). **Tallyfy for Piloting:** [Tallyfy Analytics](/products/pro/integrations/analytics/) on the piloted template can provide quantitative data on its performance, while [task comments](/products/pro/tracking-and-tasks/tasks/how-to-report-and-resolve-issues-in-tallyfy/) will capture qualitative feedback from the pilot users. ### How can I prioritize improvement ideas effectively? Often, you'll generate more good ideas than you can implement at once. Prioritization helps you focus on the changes that will deliver the most value. - **Impact/Effort Matrix**: This simple 2x2 matrix helps categorize ideas based on their potential impact (high/low) and the effort required to implement them (high/low). - **High Impact, Low Effort (Quick Wins)**: These are often the best candidates to tackle first. - **High Impact, High Effort (Major Projects)**: These require careful planning and resources. - **Low Impact, Low Effort (Fill-ins/Incremental)**: Implement if time allows, or bundle them. - **Low Impact, High Effort (Reconsider/Time Sinks)**: Generally avoid these unless there's a compelling strategic reason. - **Criteria Selection Matrix**: For more formal prioritization, list your potential solutions and score them against pre-defined criteria (e.g., cost to implement, time to implement, customer satisfaction improvement, alignment with strategic goals). Each criterion can be weighted based on its importance. **Tallyfy for Prioritization:** Ideas captured in Tallyfy [comments](/products/pro/tracking-and-tasks/tasks/how-to-report-and-resolve-issues-in-tallyfy/) can be discussed collaboratively. The anticipated impact might be informed by [Tallyfy Analytics](/products/pro/integrations/analytics/) (e.g., "this step takes 50% of the process time, so improving it would be high impact"). The effort can be judged by how easy it is to modify the [Tallyfy template](/products/pro/documenting/templates/). By systematically generating, testing, and prioritizing your improvement ideas, you can ensure that your efforts remain focused and effective. This leads to meaningful enhancements in your Tallyfy-managed processes. - **[Using comments and AI for process improvement](https://tallyfy.com/products/pro/tutorials/how-to/process-improvement/how-tallyfy-comments-and-ai-supercharge-process-improvement/)**: Tallyfy enhances traditional process improvement through contextual task comments that capture real-time feedback directly where work happens and AI capabilities that can generate process templates from plain language descriptions while analyzing patterns to suggest optimizations creating an agile cycle of execution observation and rapid template updates. ## How can Tallyfy go beyond traditional process improvement methods? Traditional process improvement often relies on periodic workshops, manual data collection, and suggestion boxes. While valuable, these methods can be slow and disconnected from the actual work. Beyond supporting traditional process improvement methodologies, Tallyfy offers unique, built-in features that can significantly accelerate and enhance your efforts. Two powerful examples are its contextual **improvement comments** and emerging **AI capabilities**. ### How do contextual comments capture insights at the source? One of the simplest yet most effective ways to identify improvement opportunities involves listening to the people doing the work. Tallyfy's [comment feature on tasks](/products/pro/tracking-and-tasks/tasks/how-to-report-and-resolve-issues-in-tallyfy/) serves as an invaluable tool for this: - **In-Context Feedback**: When a team member encounters an issue, a point of confusion, or has an idea for a better way to complete a task, they can leave a comment directly on that specific step within an active process. This means feedback is captured immediately and in the precise context where it's relevant. - **No Lost Ideas**: Suggestions aren't lost in emails, forgotten in meetings, or jotted on sticky notes. They are permanently attached to the process step, available for review by process owners and managers. - **Collaborative Problem-Solving**: Comments can spark discussions among team members and stakeholders directly within Tallyfy, fostering a collaborative approach to identifying and refining potential improvements. *"Tallyfy's comments turn every task into a potential improvement opportunity, crowdsourcing intelligence from your entire team." ### How does AI-powered process creation provide intelligent suggestions? Tallyfy is increasingly incorporating Artificial Intelligence (AI) to make process management and improvement even smarter: 1. **AI for Initial Process Capture**: Getting your existing processes documented is often the first hurdle. Tallyfy's AI can help you get started faster: * Describe your process in plain language, and Tallyfy AI can generate a draft [template](/products/pro/documenting/templates/). * Upload legacy documents (like Word checklists or procedural outlines), and Tallyfy AI can help convert them into structured, actionable templates. * *Benefit*: This overcomes the "blank page syndrome" and quickly gets your processes into a format where they can be analyzed, run, and improved. 2. **AI-Driven Improvement Suggestions (Emerging Capability)**: As Tallyfy gathers data on how your processes run (e.g., from [analytics](/products/pro/integrations/analytics/) and patterns in [comments](/products/pro/tracking-and-tasks/tasks/how-to-report-and-resolve-issues-in-tallyfy/)), it aims to provide intelligent suggestions for optimization. This could include: * Identifying steps that are frequently commented on as problematic. * Suggesting reordering of steps based on observed inefficiencies. * Highlighting steps that might be good candidates for automation or simplification. * *Benefit*: AI can act as a proactive assistant, spotting patterns or opportunities that might be missed in manual reviews, thereby speeding up the analysis and improvement cycle. ### How do comments, AI, and rapid iteration create a virtuous improvement cycle? When combined, Tallyfy's features create a powerful, virtuous cycle for continuous process improvement: 1. **Execute & Observe**: Teams run processes using Tallyfy templates. 2. **Capture Insights**: Users provide in-context feedback and improvement ideas via **comments** on tasks. 3. **Analyze & Suggest**: Process owners review comments. **AI** analyzes process data and comment patterns to highlight issues or suggest potential improvements. 4. **Refine & Implement**: Process owners make informed decisions and update the Tallyfy **template**. Because [template updates are instant](/products/pro/documenting/templates/edit-templates/) for all new process launches (no versioning delays), the improvement is deployed immediately. 5. **Monitor & Repeat**: The improved process runs, performance is monitored via **analytics**, and the feedback loop continues with new comments. This agile loop allows for rapid, iterative enhancements. This makes process improvement a dynamic and ongoing part of your operations, rather than a static, periodic project. By using these smart tools, Tallyfy not only helps you manage your current processes but actively assists you in making them better, faster, and more efficient over time. - **[Identify customer needs and CTQ requirements](https://tallyfy.com/products/pro/tutorials/how-to/process-improvement/identifying-customer-needs-and-critical-to-quality-ctq-requirements/)**: Translating customer needs into measurable goals involves capturing the Voice of the Customer through surveys interviews and feedback analysis then converting these insights into specific measurable Critical to Quality requirements that can be built into process design and tracked for performance. ## Translating customer needs into measurable goals Process improvement initiatives achieve the best results when they are laser-focused on what truly matters to your customers. Before you can improve a process to better serve them, you first need to deeply understand their needs, expectations, and perceptions of value. This involves capturing the **Voice of the Customer (VOC)** and translating it into measurable **Critical to Quality (CTQ)** requirements. ### Capturing the Voice of the Customer (VOC) The Voice of the Customer refers to the collective needs, wants, expectations, and feedback (both positive and negative) that your customers express about your products, services, or processes. Effectively capturing the VOC is the foundation for customer-centric improvement. Here are some common ways to listen in an office or service environment: - **Surveys**: Systematically collect feedback on satisfaction, specific process touchpoints, or overall experience. - **Interviews**: Conduct one-on-one discussions with a representative sample of customers to gain deep insights into their perspectives and pain points. - **Feedback Forms**: Embed simple feedback mechanisms within your Tallyfy processes or at the end of service delivery. - **Support Tickets & Complaints**: Analyze patterns in customer issues and complaints – they often point directly to process deficiencies. - **Social Media & Review Sites**: Monitor what customers are saying about you publicly. - **Sales & Account Management Teams**: These teams are often on the frontline and have valuable insights into customer sentiment and needs. :::note[Focus on Listening] When gathering VOC, the primary goal is to *listen* and understand, not to defend current processes or jump to solutions. Ask open-ended questions and probe for underlying needs. ::: ### Understanding customer needs with the Kano Model Not all customer needs are created equal, and understanding their different types can help prioritize improvements. The Kano Model provides a useful framework: - **Must-bes (Basic Expectations)**: These are unspoken requirements that customers absolutely expect. If not met, they cause extreme dissatisfaction. If met, they don't necessarily increase satisfaction – they are just the baseline. *Example: For a Tallyfy-managed client onboarding process, a **Must-be** is that all required legal documents are correctly processed.* - **One-dimensionals (Performance Needs)**: With these, the more you provide, the more satisfied the customer becomes (and vice-versa). Customers are usually vocal about these. *Example: The faster the onboarding process is completed in Tallyfy, the happier the client.* - **Delighters (Excitement Needs)**: These are unexpected positive features or service aspects that can create a "wow" effect and significantly boost satisfaction. Customers don't usually ask for these. *Example: Proactively sending a personalized welcome kit with helpful resources halfway through the Tallyfy onboarding process could be a **Delighter**.* Understanding where your process features and outcomes fall on the Kano model helps you focus improvements on maintaining Must-bes, excelling at One-dimensionals, and strategically adding Delighters to exceed customer expectations. ### Defining Critical to Quality (CTQ) requirements Once you've gathered the Voice of the Customer, the next step involves translating those often qualitative needs into specific, measurable process characteristics. These are your Critical to Quality (CTQ) requirements. CTQs bridge the gap between what customers say they want and what your processes actually need to deliver. Good CTQs are SMART: - **S**pecific: Clearly defined and unambiguous. - **M**easurable: You can quantify performance against them. - **A**chievable: It's possible to meet the requirement. - **R**elevant: Directly linked to a customer need and business goal. - **T**ime-bound: Has a timeframe or frequency associated with it (if applicable). For example: - **VOC**: "I need my support query resolved quickly." - **CTQ**: "Resolve 95% of urgent support tickets within 4 business hours." A **CTQ Tree** can be a helpful visual tool to break down broad customer needs into more granular, measurable CTQs. Start with a general need, then ask "what does that mean?" or "how would we measure that?" to identify specific characteristics. ### Designing Tallyfy processes around CTQs Once you've identified your customers' CTQs, the next step involves designing or modifying your processes to ensure these critical requirements are consistently met. Tallyfy enables you to build and manage processes with your customers' CTQs at the forefront: - **Set Deadlines**: Define task and process deadlines in Tallyfy based on customer-driven CTQs for speed and timeliness. - **Use Form Fields**: Capture precise customer requirements or critical data points directly within Tallyfy tasks using [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/). - **Embed Clear Instructions**: Ensure steps are performed correctly to meet quality-related CTQs by providing detailed instructions, checklists, or even video guides within Tallyfy tasks. - **Track Performance**: Use Tallyfy's real-time tracking and [analytics](/products/pro/integrations/analytics/) to monitor if your processes are consistently meeting the targets set by your CTQs (e.g., on-time completion, error rates if captured). :::tip[Customer Feedback in Tallyfy] Incorporate a dedicated step in your Tallyfy [customer-facing templates](/products/pro/documenting/templates/) (like order fulfillment or service delivery) to request feedback. Tailor the questions to gather input on aspects directly related to your key CTQs. ::: By actively listening to your customers and translating their needs into measurable CTQs, you can ensure your process improvement efforts are focused on what truly creates value. This leads to more impactful results and stronger customer relationships. - **[Implementing and sustaining improvements](https://tallyfy.com/products/pro/tutorials/how-to/process-improvement/implementing-changes-and-sustaining-improvements-with-tallyfy/)**: Successful process improvement implementation requires embedding changes directly into workflow systems like Tallyfy rather than relying on traditional training methods and sustaining those improvements through standardization and visibility monitoring combined with continuous feedback loops and regular performance reviews using analytics data. ## How can I ensure process improvements deliver lasting benefits? Identifying a great improvement idea is only half the battle. Successfully implementing it and ensuring it delivers lasting benefits is equally critical. This is where the "Improve" and "Control" aspects of methodologies like DMAIC come into play, focusing on rolling out changes effectively and making them stick. ### How can I implement my process changes effectively? Once you've identified improvement opportunities and designed better workflows, the next critical phase involves putting those changes into practice and ensuring they stick. This involves more than just announcing a new process. It requires careful execution, communication, and ongoing monitoring. Traditional training approaches fail because of the [Ebbinghaus forgetting curve](/products/pro/tutorials/why-documentation-training-fails-forgetting-curve/), which shows people forget 90% of what they learn within a week. Instead of relying on memory, successful implementations embed the new process directly into the workflow. **Implementing with Tallyfy:** * **Update Templates Instantly**: Modify your [procedure templates](/products/pro/documenting/templates/) or [document templates](/products/pro/documenting/documents/) in Tallyfy. All new [processes](/products/pro/tracking-and-tasks/processes/) launched from that template will automatically use the updated version. There's no need to redistribute paper documents or worry about outdated versions. ### How can I sustain improvements with Tallyfy? Making improvements is one thing; making them last is another. Tallyfy helps embed new ways of working: * **Standardization**: Because processes are executed within Tallyfy, adherence to the new standard is inherently encouraged. Deviations are harder to make unintentionally. * **Visibility & Monitoring**: Use **[Tallyfy Analytics](/products/pro/integrations/analytics/)** and the **[Tracker view](/products/pro/tracking-and-tasks/tracker-view/)** to monitor if the new process is being followed and if it's delivering the expected benefits (e.g., faster completion times, fewer errors). * **Feedback Loops**: Continue to use **[Tallyfy's comment features](/products/pro/tracking-and-tasks/tasks/how-can-i-manage-comments-in-tallyfy/)** for ongoing feedback on the improved process. This allows for further minor adjustments and reinforces a culture of continuous improvement. * **Regular Reviews**: Schedule periodic reviews of your key processes. The data from Tallyfy can inform these reviews, helping you identify if the process is still optimal or if new bottlenecks have emerged. By using Tallyfy's features, implementing and sustaining process improvements becomes a more integrated and less burdensome activity. The platform itself helps enforce the new standard, monitors its performance, and facilitates ongoing refinement throughout your organization. - **[Integrating agile and design thinking into process improvement](https://tallyfy.com/products/pro/tutorials/how-to/process-improvement/integrating-agile-and-design-thinking/)**: Combining Agile's sprint-based delivery and Design Thinking's human-centered innovation with Lean Six Sigma's rigor creates a powerful methodology blend that transforms slow rigid improvement projects into rapid iterative cycles delivering tangible value every one to two weeks through techniques like minimum viable improvements and design sprints while tools like Tallyfy enable instant prototyping and A/B testing of process changes. ## How can agile and design thinking accelerate improvements? Traditional process improvement can feel slow and rigid. Projects drag on for months. Solutions address symptoms rather than reimagining possibilities. Teams lose momentum waiting for perfect data. Modern organizations need faster, more innovative approaches. Enter Agile and Design Thinking - methodologies that inject speed, creativity, and human-centeredness into your improvement efforts. Agile brings iterative speed and continuous feedback. Design Thinking adds creative problem-solving and empathy. Combined with Lean Six Sigma's rigor, you get the best of all worlds: disciplined innovation that delivers rapid, meaningful results. ### Agile principles that transform improvement projects Forget four-month improvement projects. Agile breaks work into focused sprints, delivering value every 1-2 weeks. Here's how core Agile concepts accelerate process improvement: **Sprint-based delivery**: Instead of analyzing for months before implementing anything, deliver improvements incrementally. Week 1: Fix the obvious bottleneck. Week 2: Streamline the handoff. Week 3: Automate the routine task. Each sprint produces tangible value while learning informs the next iteration. **Daily standups for improvement teams**: Replace weekly status meetings with 15-minute daily check-ins. What did you complete yesterday? What will you work on today? What's blocking progress? This rhythm maintains momentum and surfaces issues immediately. **Kanban boards for visual management**: Make improvement work visible. Create columns for "To Do," "In Progress," "Testing," and "Done." Move improvement tasks across the board. Everyone sees progress at a glance - no status reports needed. **Minimum Viable Improvements (MVI)**: Don't wait for the perfect solution. What's the smallest change that delivers value? A bank significantly reduced loan processing time by simply reordering two steps - implemented in one day rather than waiting for full process redesign. ### Design thinking: reimagining what's possible While Lean Six Sigma excels at optimization, Design Thinking enables transformation. It shifts focus from "How do we fix this process?" to "How might we delight our customers?" **The five stages of design thinking in process improvement**: 1. **Empathize**: Understand users' real experiences, not just process metrics. Shadow customer service reps for a day. Listen to customer calls. Feel their frustrations firsthand. 2. **Define**: Reframe problems from the user's perspective. Instead of "Reduce processing time," ask "How might we give customers confidence their request is progressing?" 3. **Ideate**: Generate wild ideas without judgment. Use "Yes, and..." thinking. What if customers could track requests like pizza delivery? What if AI predicted and prevented common errors? 4. **Prototype**: Build quick, cheap tests of concepts. Mock up the new workflow in Tallyfy. Create paper prototypes of new forms. Test ideas before heavy investment. 5. **Test**: Get rapid feedback from real users. Watch them use your prototype. What confuses them? What delights them? Iterate based on learning. ### Practical integration strategies **Start with Design Thinking for breakthrough innovation**: When facing complex customer problems or need for dramatic improvement, begin with Design Thinking. A healthcare provider used journey mapping to discover patients' biggest frustration wasn't wait time - it was uncertainty. They created a real-time status system that dramatically improved satisfaction without reducing actual wait times. **Apply Agile for rapid implementation**: Once you've identified improvements through DMAIC analysis or Design Thinking ideation, use Agile sprints for implementation. Break changes into two-week chunks. Test with small groups. Scale what works. **Use Lean Six Sigma for optimization**: After Agile implementation, apply Six Sigma tools to fine-tune performance. Measure results. Identify remaining waste. Standardize best practices. The insurance company that reorganized into case teams (Agile implementation) later used statistical analysis to optimize team sizes and skill mixes. ### Creating psychological safety for innovation Innovation requires risk-taking. Risk-taking requires safety. Build an environment where teams feel secure to experiment: - **Celebrate intelligent failures**: When experiments don't work, mine them for learning. "What did we discover?" - **Time-box experiments**: "Let's try this for two weeks" feels safer than permanent change - **Start small**: Test with one team before rolling out company-wide - **Share stories**: Publicize both successes and learning from failures ### Tools and techniques that work **Rapid improvement events with Agile structure**: - Monday: Understand current state (Gemba walk, data review) - Tuesday: Generate solutions (Design Thinking exercises) - Wednesday: Prototype and test top ideas - Thursday: Implement quick wins - Friday: Plan next sprint, share learnings **Design sprints for process reimagination**: Compress months of work into one focused week: - Day 1: Map the challenge and pick target - Day 2: Sketch competing solutions - Day 3: Decide on best ideas to prototype - Day 4: Build realistic prototype in Tallyfy - Day 5: Test with real users **Scrum for continuous improvement teams**: - **Product Owner**: Process owner who prioritizes improvements - **Scrum Master**: Facilitates team and removes obstacles - **Development Team**: 3-7 people who implement improvements - **Sprints**: 2-week cycles of focused improvement work ### Using Tallyfy to enable agile improvement Tallyfy naturally supports agile, iterative improvement: **Rapid prototyping**: Clone templates to test changes without affecting live processes. See immediate impact. **A/B testing**: Run old and new processes simultaneously. Compare results. Let data guide decisions. **Instant deployment**: Push improvements immediately. No waiting for IT releases or training rollouts. **Continuous feedback**: Comments on tasks capture improvement ideas in real-time. Analytics show impact instantly. ### Common integration pitfalls **Analysis paralysis meets wild ideation**: Balance is key. Time-box both analysis and creative phases. One week of data gathering, one week of ideation, then start testing. **Agile chaos without Lean discipline**: Rapid iteration still needs standards. Document what works. Update templates. Don't let "agile" become "anything goes." **Innovation theater**: Sticky notes and design workshops must produce real changes. Connect every creative session to specific process improvements in Tallyfy. **Forgetting the control phase**: Agile delivery can skip sustainability. Build measurement and control into every sprint, not just at project end. ### The multiplication effect When you combine these approaches, magic happens: - DMAIC provides structure and rigor - Lean eliminates waste and creates flow - Agile delivers speed and adaptability - Design Thinking brings innovation and user focus A telecommunications company applied this integrated approach to customer onboarding. Design Thinking revealed customers wanted transparency, not just speed. Agile sprints rapidly tested status notifications. Lean removed redundant steps. Six Sigma ensured consistency. Result: significantly faster onboarding AND notably higher satisfaction scores. The future of process improvement isn't choosing between methodologies - it's skillfully blending them for your context. Start where you are, use what works, and continuously evolve your approach. - **[Introduction to DMAIC](https://tallyfy.com/products/pro/tutorials/how-to/process-improvement/introduction-to-dmaic-for-process-improvement/)**: The DMAIC framework provides a five-phase systematic methodology (Define Measure Analyze Improve Control) that transforms process improvement from symptom-treating guesswork into data-driven sustainable change by ensuring teams address root causes rather than surface issues while maintaining long-term performance gains. ## How does the DMAIC framework support process improvement? When faced with a complex process problem, it's tempting to jump straight to a solution. However, without a systematic approach, you might only address symptoms rather than the true root causes. The **DMAIC** methodology provides a proven, five-phase framework to guide your process improvement efforts. This ensures changes are data-driven and sustainable. DMAIC stands for: - **D**efine - **M**easure - **A**nalyze - **I**mprove - **C**ontrol This systematic approach evolved from manufacturing excellence at companies like Motorola and General Electric, where reducing defects to near-zero levels became critical for competitiveness. Today, DMAIC applies equally well to service processes - from client onboarding to invoice processing. ### Why systematic improvement matters Consider this: 99% accuracy sounds impressive, right? Yet at that performance level, we'd see 20,000 lost articles of mail per hour and 5,000 incorrect surgical operations per week. Process excellence demands a more rigorous standard. DMAIC provides the discipline to achieve breakthrough improvements, not just incremental gains. Let's explore what each phase entails, keeping in mind how Tallyfy can support your thinking and actions at each stage. ### Define: What is the problem and what are the goals? The Define phase focuses on clearly understanding the problem you're trying to solve, who it affects, and what a successful outcome looks like. Key activities include: - **Problem Statement**: Articulating the issue concisely (e.g., "Client onboarding takes too long, averaging 15 days, leading to client dissatisfaction."). - **Goal Statement**: Defining specific, measurable improvement targets (e.g., "Reduce average client onboarding time to 7 days within 3 months."). - **Scope**: Clarifying the boundaries of the process under review. - **Stakeholders**: Identifying who is impacted by the process and the improvement effort. This phase often involves creating a basic **Project Charter**, a document summarizing these points. A well-crafted charter becomes your North Star throughout the project. #### The power of precise problem statements Here's a secret: half the battle is won when you define the problem correctly. Avoid these common pitfalls: - Jumping to causes: "Poor training causes delays" (that's analysis, not definition) - Embedding solutions: "We need automation to fix slow processing" (that's improvement, not definition) - Being too vague: "Customer service needs improvement" (which aspect? how much?) Instead, use the 5W1H approach - What's happening? Where? When? Who's affected? Why does it matter? How much impact? For instance: "Invoice processing errors have increased 40% over the past quarter, affecting 150+ customers monthly and causing $75K in rework costs." **Tallyfy in the Define Phase:** * **Process Documentation**: Use Tallyfy to [document the current state of the process](/products/pro/tutorials/how-to/process-improvement/understanding-your-current-processes-with-tallyfy/) you aim to improve. Your Tallyfy template becomes a clear definition. * **Identify Stakeholders**: Note down key stakeholders who will be impacted or involved. ### Measure: How does the process currently perform? Before you can improve a process, you need to understand its current performance. The Measure phase focuses on collecting data to establish a baseline and pinpoint problem areas. This phase involves: - Identifying key metrics related to the problem and goals (e.g., cycle time, error rates, customer satisfaction scores). - Developing a data collection plan. - Gathering and validating the data. #### Understanding variation - your process's fingerprint Every process exhibits variation. The key question: is your variation predictable (common cause) or unpredictable (special cause)? Picture a coffee shop - slight variations in brewing time are normal, but a broken espresso machine creates abnormal delays. Managing by averages alone misses this critical distinction. Smart measurement reveals patterns: - **Cycle time distribution**: Not just "average 5 days" but understanding why some take 2 days while others take 10 - **First-pass yield**: What percentage of work completes correctly without rework? - **Process capability**: Can your process consistently meet customer requirements? Remember: customers experience your entire range of performance, not your average. If pizza delivery averages 30 minutes but varies from 15 to 90 minutes, customers remember the extremes. **Tallyfy in the Measure Phase:** * **Built-in Analytics**: [Tallyfy Analytics](/products/pro/integrations/analytics/) automatically captures data like task completion times, process duration, and identifies bottlenecks (steps where tasks queue up). This provides a baseline measurement without manual tracking. * **Custom Data Collection**: If specific data points aren't automatically tracked, you can add [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) to your Tallyfy tasks to collect this information as the process runs. * **Real variation visibility**: Unlike spreadsheets showing averages, Tallyfy reveals the full distribution of your process performance - essential for understanding true capability. ### Analyze: What are the root causes of the problem? With data in hand, the Analyze phase delves into identifying the fundamental reasons—the root causes—behind the process problem. This involves asking "why" repeatedly until you move beyond symptoms. Common techniques include the **5 Whys** and **Fishbone Diagrams** (which we cover in more detail in [Simple root cause analysis techniques](/products/pro/tutorials/how-to/process-improvement/simple-root-cause-analysis-techniques/)). #### Moving beyond surface-level analysis Too often, teams stop at the first plausible explanation. Customer complaints about slow service? Must be understaffing. But dig deeper - maybe work arrives in unpredictable bursts, creating artificial peaks. Or perhaps 80% of delays occur in just one process step that nobody noticed. Remember that elapsed time doesn't equal effort time. A task might take 3 days to complete but only require 30 minutes of actual work - the rest could be waiting time. See [how to track time spent on tasks](/products/pro/tutorials/how-to/track-time-in-tasks/) to capture real effort data. Effective analysis combines multiple perspectives: - **Process analysis**: Where does work actually get stuck? Which handoffs fail? - **Data patterns**: Do problems cluster around certain times, customers, or conditions? - **Human factors**: What makes the process difficult for people to execute consistently? One powerful insight: most process problems stem from the system, not the people. W. Edwards Deming, the quality guru, estimated that 94% of problems come from the process itself. Stop blaming individuals - fix the process. **Tallyfy in the Analyze Phase:** * **Visualizing Bottlenecks**: The [Tracker view](/products/pro/tracking-and-tasks/tracker-view/) provides visibility into where work is piling up or taking longer than expected. [Tallyfy Analytics](/products/pro/integrations/analytics/) lets you connect your own BI tools to analyze this data in custom dashboards. * **Reviewing Comments**: [Task comments](/products/pro/tracking-and-tasks/tasks/how-to-report-and-resolve-issues-in-tallyfy/) can reveal qualitative data about problems, frustrations, or recurring issues within the process. * **Pattern recognition**: Tallyfy's data helps identify whether delays are random or follow patterns - crucial for targeting the right root causes. ### Improve: How can we fix the root causes? Once root causes are identified, the Improve phase involves brainstorming, evaluating, and testing potential solutions designed to address those causes. This might involve: - Generating a range of improvement ideas. - Selecting the most promising solutions based on criteria like impact and feasibility. - Piloting the chosen solutions on a small scale to test their effectiveness. #### The art of solution design Great solutions share common traits - they're simple, foolproof, and address root causes rather than symptoms. Consider these proven improvement strategies: **Error-proofing (Poka-Yoke)**: Make mistakes impossible or immediately obvious. A gas pump nozzle that won't fit in a diesel tank prevents costly errors better than warning signs. **Flow optimization**: Reduce handoffs, eliminate waiting, process work continuously. One insurance company cut claim processing from 15 days to 3 by simply reorganizing work from departmental batches to end-to-end case teams. **Standard work**: Not rigid bureaucracy, but capturing the current best way to perform tasks. Think of it as democratizing expertise - everyone performs at the level of your best operator. Always pilot solutions before full rollout. What works in theory might fail in practice. Small-scale tests reveal unexpected issues while the stakes remain low. **Tallyfy in the Improve Phase:** * **Modifying Templates**: Implement your proposed solutions by directly [editing the Tallyfy template](/products/pro/documenting/templates/edit-templates/). This immediately changes the standard for future process instances. * **Pilot Small Changes**: You can easily clone a template, make modifications for a pilot, and run a few instances to test the improvement before rolling it out to the main template. * **Built-in error-proofing**: Use conditional logic and required fields to prevent common mistakes at the source. ### Control: How do we ensure the improvements stick? The final phase, Control, focuses on ensuring the implemented improvements are sustained over time and don't regress to old habits. This includes: - Standardizing the new process. - Monitoring its performance continuously. - Creating a plan to address any future deviations. #### Building sustainability into improvements Here's an uncomfortable truth: 70% of improvement initiatives fail to sustain their gains after 18 months. Why? Because organizations treat Control as an afterthought rather than a critical success factor. Effective control requires three elements: **Process discipline**: The new way must become easier than the old way. If people need to remember 10 new rules, they'll revert under pressure. Build the improvements into the process itself. **Visual management**: Make performance visible in real-time. When everyone can see process health at a glance, problems get addressed before they escalate. A dashboard beats a monthly report every time. **Response plans**: Define what happens when performance drifts. Who investigates? What triggers escalation? Without clear accountability, small deviations become major breakdowns. Remember: Control isn't about rigid enforcement. It's about creating conditions where good performance happens naturally. **Tallyfy in the Control Phase:** * **Standardized Execution**: Running processes in Tallyfy ensures the new, improved method is followed consistently. * **Ongoing Monitoring**: Continue to use Tallyfy Analytics to monitor the performance of the improved process against the baseline and desired targets. * **Alerts & Notifications**: Built-in deadline alerts and notifications help maintain control and ensure tasks stay on track. * **Documentation is Live**: The Tallyfy template itself is the living documentation of the controlled process, always up-to-date. * **Automatic accountability**: Task assignments and deadline tracking create natural ownership without micromanagement. While a full DMAIC project can be extensive, understanding its structured approach proves valuable even for smaller improvement efforts. Tallyfy provides tools that simplify and support each phase, making data-driven improvement more accessible to teams. ### Quick wins vs. transformation Not every problem requires a full DMAIC project. Use this framework to decide your approach: **Quick wins** (Days to weeks): - Single-step problems - Clear root cause - Known solution - Limited stakeholders **Rapid improvement** (2-4 weeks): - Focused scope - Moderate complexity - Team-based solution - Some data needed **Full DMAIC** (2-4 months): - Complex, cross-functional issues - Unknown root causes - Significant impact - Data-driven approach critical The beauty of DMAIC? It scales. Use all five phases for complex transformations, or apply specific tools for targeted improvements. Either way, you're building a culture where problems get solved systematically, not symptomatically. - **[Kaizen - continuous small improvements](https://tallyfy.com/products/pro/tutorials/how-to/process-improvement/kaizen-making-continuous-small-improvements-with-tallyfy/)**: Small ongoing positive changes through the Kaizen philosophy empower everyone to contribute incremental enhancements that are less disruptive and face less resistance while building a cumulative effect over time through continuous questioning and standardization of improvements. ## How can small, consistent process changes create powerful results? **Kaizen**, a Japanese term meaning "change for good" or "continuous improvement," is a philosophy that focuses on making small, ongoing, positive changes to improve processes and reduce waste. Unlike large-scale overhauls, Kaizen empowers everyone in the organization to contribute to incremental enhancements regularly. ### Why is Kaizen effective for office processes? While grand projects have their place, the Kaizen approach offers distinct advantages. This is especially true in dynamic office and service environments: - **Less Disruptive**: Small changes are easier to implement and less likely to cause major disruptions to daily operations. - **Empowers Employees**: It values the insights of people doing the work, fostering a sense of ownership and engagement. - **Reduces Resistance**: Incremental adjustments often face less resistance than radical transformations. - **Fosters a Learning Culture**: Each small change is an opportunity to learn and refine, building a cumulative effect over time. - **Low Cost, High Impact**: Many small improvements require minimal investment but can lead to significant collective gains in efficiency and quality. ### What are the core principles of Kaizen? - **Focus on small, incremental changes**: Aim for many minor improvements rather than a few large ones. - **Involve everyone**: Ideas for improvement should come from all levels, especially those directly involved in the process. - **Be ongoing**: Kaizen is not a one-time event but a continuous effort woven into the daily work culture. - **Standardize improvements**: Once an improvement is made and validated, it becomes the new standard to build upon. - **Question everything**: Continuously ask whether there's a better way to do things. Think of it like tidying a room: a massive one-off clean-up (big project) can be daunting. However, spending 5-10 minutes tidying a small part each day (Kaizen) makes the overall task manageable and keeps the room consistently neater. ### How does Tallyfy make Kaizen practical and easy? Tallyfy is exceptionally well-suited to support a Kaizen approach to process improvement in your office: 1. **Contextual Feedback with Tallyfy Comments**: This is a cornerstone of Kaizen in Tallyfy. Team members can leave [improvement comments directly on specific tasks](/products/pro/tracking-and-tasks/tasks/how-to-report-and-resolve-issues-in-tallyfy/) as they encounter issues or think of better ways to do things. This captures valuable, in-context suggestions that might otherwise be lost. * *Tallyfy's comment feature is your built-in Kaizen suggestion box, right where the work happens.* 2. **AI-Powered Suggestions (Future of Kaizen)**: Tallyfy is moving towards using AI to analyze patterns in process execution and comments. This means Tallyfy can proactively highlight areas for small improvements or even suggest refinements based on collective team feedback, acting as an intelligent assistant in your Kaizen efforts. 3. **Rapid Implementation via Instant Template Updates**: A core tenet of Kaizen is quick action on small improvements. When you [edit a Tallyfy template](/products/pro/documenting/templates/edit-templates/), the changes are live immediately for all new processes launched from it. There are no complex versioning delays or lengthy rollout procedures for these incremental enhancements. 4. **Visibility and Collaboration**: Tallyfy makes processes transparent. Everyone can see the steps, and [comments](/products/pro/tracking-and-tasks/tasks/how-to-report-and-resolve-issues-in-tallyfy/) facilitate collaborative discussion around these small improvement ideas before they are implemented. 5. **Easy Process Modification**: Adjusting a step, adding a clarification, or reordering tasks in a Tallyfy template is simple and doesn't require specialized skills. This lowers the barrier to making those small, frequent changes that Kaizen champions. :::tip[Cultivate a Kaizen Habit] Encourage your team to make it a habit to look for small improvement opportunities as they work through their Tallyfy tasks. Dedicate a few minutes in team meetings each week to review suggestions from Tallyfy comments and decide on quick wins to implement. ::: By embracing the Kaizen philosophy and using Tallyfy's features, you can transform process improvement from an occasional project into a daily habit. This leads to sustained gains in efficiency, quality, and team engagement. Every small step forward contributes to a significantly better overall operation over time. - **[Lean thinking - eliminate waste in office processes](https://tallyfy.com/products/pro/tutorials/how-to/process-improvement/lean-thinking-eliminating-waste-in-office-processes/)**: Lean principles help offices eliminate waste across eight categories (TIM WOODS: Transportation Inventory Motion Waiting Overproduction Over-processing Defects and Skills) while focusing on customer value through standardized processes visual management and continuous improvement enabled by workflow tools that create pull-based systems with automatic task routing and built-in analytics. ## Applying lean principles for efficient offices Lean thinking is a powerful philosophy focused on maximizing customer value while minimizing waste. Originating in manufacturing (famously with Toyota), its principles are highly effective for streamlining office and service processes. A core tenet of Lean involves identifying and eliminating "Muda" – the Japanese term for waste – which refers to any activity that consumes resources but creates no value for the customer. The journey starts with a mindset shift. Toyota's Taiichi Ohno put it simply: "All we are doing is looking at a timeline from the moment the customer gives us an order to the point when we collect the cash. And we are reducing that timeline by removing the non-value adding wastes." This perspective transforms how you view every process - from invoice processing to customer onboarding. ### Customer value definition Before you can eliminate waste, you must first understand what your customer truly values. Value is defined by what the customer is willing to pay for or what meets their explicit and implicit needs. Any step or activity in your process that doesn't contribute to this value is potentially waste. (Refer to our article on [Identifying customer needs and CTQ requirements](/products/pro/tutorials/how-to/process-improvement/identifying-customer-needs-and-critical-to-quality-ctq-requirements/) for more on this). ### The 8 Wastes (TIM WOODS) in office contexts Lean practitioners often use the acronym **TIM WOODS** to remember the eight common categories of waste. Let's explore how these apply to typical office and service environments: 1. **T - Transportation**: Unnecessary movement of information, documents, files, or even people for approvals or handoffs. * *Office Example*: Emailing large document drafts back and forth for review instead of using a collaborative Tallyfy task with all necessary files attached; routing a physical document through multiple departments for signatures when an e-signature step in Tallyfy would suffice. * *Tallyfy Helps*: Centralizes information and tasks, reducing the need to move data between systems or people unnecessarily. Clear assignments minimize misrouted work. 2. **I - Inventory**: Excess work-in-progress, backlogs of tasks, unread emails, stockpiles of outdated reports, or even too many pending approvals. * *Office Example*: A manager's inbox clogged with hundreds of approval requests; a large queue of unprocessed customer applications. * *Tallyfy Helps*: Provides visibility into workloads and queues via the [Tracker view](/products/pro/tracking-and-tasks/tracker-view/). Deadlines and automated reminders help keep work flowing, reducing inventory buildup. 3. **M - Motion**: Unnecessary physical movements (like walking to a shared printer multiple times) or digital movements (excessive clicks, navigating complex folder structures, switching between many applications). * *Office Example*: Searching across multiple shared drives and email chains to find all information related to a client case; repeatedly opening and closing different software to copy-paste information. * *Tallyfy Helps*: Consolidates all task-relevant information, instructions, and forms in one place, minimizing digital searching. Integrations can automate data transfer, reducing application switching. 4. **W - Waiting**: Idle time spent waiting for information, approvals, system responses, decisions from colleagues, or the previous step in a process to complete. * *Office Example*: A project stalled because a key decision-maker is unavailable; an employee unable to proceed because they are waiting for data from another department. * *Tallyfy Helps*: Automated notifications alert assignees when tasks are ready. Clear deadlines and visibility of task status help identify and reduce waiting times. Parallel steps can be configured for tasks that can happen simultaneously. To measure actual working time versus waiting time, see [how to track time spent on tasks](/products/pro/tutorials/how-to/track-time-in-tasks/). 5. **O - Overproduction**: Doing more work than necessary, sooner than necessary, or in greater quantities than needed. This includes creating reports no one uses or providing excessive detail. * *Office Example*: Generating a daily detailed sales report when only a weekly summary is reviewed by management; preparing a full proposal before qualifying if the client is a good fit. * *Tallyfy Helps*: Processes are launched on demand. [Conditional logic (rules)](/products/pro/documenting/templates/automations/logic-explained/) can ensure only necessary steps are activated, preventing work from being done prematurely. 6. **O - Over-processing**: Putting more work into a task than is valued by the customer. This includes unnecessary checks, excessive reviews, multiple approval layers for minor items, or using overly complex tools for simple jobs. * *Office Example*: Requiring three levels of management sign-off for a minor office supply order; reformatting a document multiple times to meet slightly different internal preferences. * *Tallyfy Helps*: Streamlines approvals with clear assignment. Standardized templates reduce unnecessary variations in how work is done. Conditional logic can bypass unnecessary approval steps based on defined criteria. 7. **D - Defects**: Errors in work that require correction, leading to rework, delays, and customer dissatisfaction. This includes data entry mistakes, incorrect calculations, or miscommunications. * *Office Example*: An invoice sent with the wrong amount; a marketing email deployed with broken links or typos. * *Tallyfy Helps*: Clear instructions, checklists, and [form fields with validation](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) within Tallyfy tasks help prevent errors. Standardized processes reduce the chance of defects due to inconsistent methods. 8. **S - Skills (Non-Utilized Talent)**: Failing to use the knowledge, skills, creativity, and experience of your team members effectively. This also includes assigning tasks to people without the right skills or burdening skilled individuals with mundane work. * *Office Example*: Not involving frontline staff in process improvement discussions; a senior analyst spending hours on basic data compilation that could be automated or delegated. * *Tallyfy Helps*: Clear role assignments ensure tasks go to the right people. [Improvement comments](/products/pro/tracking-and-tasks/tasks/how-to-report-and-resolve-issues-in-tallyfy/) empower everyone to contribute ideas, tapping into collective intelligence. :::tip[Conduct a Waste Walk in Your Processes] Review your existing Tallyfy templates step-by-step. For each step, ask yourself and your team: "Does this step exhibit any of the TIM WOODS wastes from the customer's perspective or from an efficiency standpoint?" This can be a simple yet powerful exercise. ::: ### The five principles that drive lean transformation Beyond waste elimination, lean thinking operates on five interconnected principles that create a complete system for excellence: 1. **Specify value from the customer's standpoint**: Start every process design by asking "What would the customer pay for?" A mortgage application process adds value when gathering necessary information - not when documents sit in queues between departments. 2. **Map the value stream**: Document every step from request to delivery. You'll likely discover that value-adding time represents a small fraction of total cycle time. Many organizations find their multi-week approval processes contain only minutes of actual work. 3. **Create flow**: Arrange work so it moves smoothly without interruption. This means breaking down departmental silos, reducing batch sizes, and eliminating wait times. When organizations reorganize from departmental queues to case-based teams, processing time typically drops significantly. 4. **Establish pull**: Let customer demand trigger work, not arbitrary schedules. Instead of processing invoices in weekly batches (causing delays early in the week and rushes at the end), process them as they arrive. Tallyfy's on-demand process launching naturally creates pull. 5. **Seek perfection through continuous improvement**: The journey never ends. Each improvement reveals new opportunities. Toyota calls this "kaizen" - the relentless pursuit of better ways. Small daily improvements compound into dramatic results. ### Advanced lean concepts for knowledge work **Heijunka (Level Loading)**: Smooth out workload peaks and valleys. Rather than having Monday morning chaos and Friday afternoon lulls, distribute work evenly. HR teams often reduce overtime significantly by spreading interview scheduling throughout the week instead of clustering on specific days. **Standard work for variable processes**: Office work seems too variable to standardize? Think again. Create flexible standards - like interview templates with core questions plus role-specific additions. This ensures consistency while allowing necessary variation. **Visual management beyond boards**: Make work status instantly visible. Tallyfy's tracker view serves as a digital andon board, showing exactly where work stands without asking anyone. When problems can't hide, they get solved faster. ### Using Tallyfy to combat office waste By making your processes visible, standardized, and executable in Tallyfy, you create an environment where these common office wastes are easier to spot, analyze, and systematically eliminate. This leads to more efficient operations, higher quality output, and ultimately better service for your customers and a less frustrating experience for your team. The platform naturally embeds lean principles: - **Built-in pull system**: Processes launch on demand, not by schedule - **Automatic flow**: Tasks route instantly to the next person without manual handoffs - **Standard work made easy**: Templates ensure everyone follows best practices - **Continuous improvement enabled**: Comments and analytics reveal improvement opportunities - **[Measuring process performance with sigma levels](https://tallyfy.com/products/pro/tutorials/how-to/process-improvement/measuring-process-performance-with-sigma-levels/)**: Process sigma levels provide a universal quality metric that measures defects per million opportunities enabling organizations to benchmark performance across different processes understand true capability beyond simple averages and set meaningful improvement targets based on world-class standards rather than arbitrary goals. ## What are sigma levels and why do they matter? Sigma levels quantify process performance by measuring defects per million opportunities (DPMO). This universal metric enables meaningful comparisons across different processes - from invoice accuracy to on-time delivery. Understanding sigma levels helps you set realistic improvement targets based on world-class benchmarks rather than arbitrary percentages. Most organizations operate between 2 and 4 sigma. At 3 sigma (93.3% defect-free), you might think performance is good. Yet this means 66,807 defects per million opportunities. For a hospital, that's unacceptable medication errors. For a bank, it's thousands of incorrect transactions. The journey to higher sigma levels transforms "good enough" into genuine excellence. ### Understanding the sigma scale The sigma scale uses standard deviations to measure how well a process meets customer requirements: - **1 Sigma**: 31% successful (690,000 DPMO) - Barely functional - **2 Sigma**: 69% successful (308,537 DPMO) - Significant errors - **3 Sigma**: 93.3% successful (66,807 DPMO) - Typical performance - **4 Sigma**: 99.38% successful (6,210 DPMO) - Good performance - **5 Sigma**: 99.977% successful (233 DPMO) - Excellent performance - **6 Sigma**: 99.99966% successful (3.4 DPMO) - World class ### The real impact of sigma levels Consider everyday examples to grasp the dramatic differences: At **99% quality (3.8 sigma)**: - 20,000 lost articles of mail per hour - 5,000 incorrect surgical operations per week - 2 short or long landings at major airports daily At **99.99966% quality (6 sigma)**: - 7 lost articles of mail per hour - 1.7 incorrect surgical operations per week - 1 short or long landing every 5 years The difference? Customer trust, operational costs, and competitive advantage. ### How to calculate your process sigma Calculating sigma levels requires understanding three key concepts: 1. **Defect opportunities**: Each customer requirement represents an opportunity for defects. An invoice might have 5 opportunities - correct amount, right address, accurate items, proper formatting, timely delivery. 2. **Defects vs. defectives**: A defective unit may have multiple defects. One incorrect invoice (defective) might have wrong amount AND wrong address (two defects). 3. **Sample size matters**: Ensure your data represents typical performance, not best-case or worst-case scenarios. **The calculation**: 1. Count total defects in your sample 2. Multiply units processed × opportunities per unit 3. Calculate DPMO: (Defects ÷ Total Opportunities) × 1,000,000 4. Convert DPMO to sigma using a conversion table **Example**: Processing 500 insurance claims with 4 requirements each (completeness, accuracy, timeliness, proper documentation) = 2,000 opportunities. Finding 40 defects gives DPMO of 20,000, approximately 3.4 sigma. ### Using Tallyfy to track sigma performance Transform sigma measurement from complex calculations to automated insights: **Set up measurement**: - Define defect opportunities as required fields in task forms - Use validation rules to catch defects at the source - Track rework tasks as defect indicators **Monitor performance**: - Analytics automatically calculate cycle times and completion rates - Process health indicators show performance trends - Export data for detailed sigma calculations **Drive improvement**: - Comments capture why defects occur - Pattern analysis reveals common failure points - A/B test process changes to improve sigma levels ### Setting meaningful targets Avoid arbitrary goals like "reduce errors by 50%." Instead, use sigma levels to set context-appropriate targets: **Life-critical processes** (healthcare, aviation): Target 5-6 sigma - Even small error rates have severe consequences - Investment in near-perfection pays off in lives saved **Financial processes** (billing, payroll): Target 4-5 sigma - Errors directly impact customer trust and regulatory compliance - Cost of prevention less than cost of correction **Internal processes** (expense reports, meeting scheduling): Target 3-4 sigma - Balance improvement costs with business impact - Focus on customer-facing processes first ### Common pitfalls in sigma measurement **Measuring activities, not outcomes**: Tracking "emails sent" rather than "customer issues resolved" misses the point. Focus on what customers value. **Ignoring hidden factories**: Rework often hides in unmeasured activities. That "quick fix" culture masks true sigma performance. Make rework visible. **Cherry-picking data**: Measuring only your best performers or easiest cases inflates sigma levels. Include all typical work for accurate baselines. **Overlooking customer requirements**: Internal quality standards may not match customer expectations. A perfectly formatted report delivered late still fails the customer. ### Beyond the numbers Sigma levels provide powerful insights, but remember: - **Context matters**: 4 sigma might be excellent for one process, inadequate for another - **Improvement costs escalate**: Moving from 3 to 4 sigma typically costs far less than 5 to 6 - **Cultural change required**: Higher sigma levels demand systematic thinking, not heroic efforts The goal isn't perfection everywhere - it's appropriate quality for each process. Use sigma levels to make informed decisions about where to invest improvement efforts for maximum customer impact. - **[Simple root cause analysis techniques](https://tallyfy.com/products/pro/tutorials/how-to/process-improvement/simple-root-cause-analysis-techniques/)**: Root Cause Analysis techniques like the 5 Whys and Fishbone Diagram help identify fundamental reasons behind process problems rather than just treating symptoms by systematically exploring cause-and-effect relationships and categorizing potential issues for lasting improvements. ## How can I find the real reasons behind process problems? When a process isn't performing as expected, it's easy to fix the immediate symptom. However, for lasting improvement, you need to dig deeper and uncover the **root cause(s)** – the fundamental reason(s) why the problem is occurring. Addressing symptoms provides temporary relief, but tackling root causes prevents the problem from recurring. Root Cause Analysis (RCA) is a collection of techniques to help you do just that. Here are two simple yet powerful methods well-suited for office and service environments. ### How does the 5 Whys technique help me understand problems? The **5 Whys** technique is a straightforward and surprisingly effective way to explore the cause-and-effect relationships underlying a particular problem. The basic idea involves stating the problem and then repeatedly asking "Why?" (typically about five times) until you arrive at a fundamental cause. **How to use the 5 Whys:** 1. **Define the Problem Clearly**: Start with a specific problem statement. For example, "The monthly sales report was submitted two days late." 2. **Ask "Why?"**: Ask why the problem occurred. * *Problem*: The monthly sales report was submitted two days late. * *Why?* Because the data from the CRM system was not available on time. 3. **Ask "Why?" Again**: Take the answer from step 2 and ask why that happened. * *Why was the CRM data not available on time?* Because the CRM system had unscheduled downtime on the data extraction day. 4. **Continue Asking "Why?"**: Repeat the process for each answer. * *Why did the CRM have unscheduled downtime?* Because an emergency patch was applied without proper testing. * *Why was the patch applied without proper testing?* Because the IT team felt pressured to fix an urgent bug quickly. * *Why did the IT team feel pressured?* Because there isn't a clear protocol for balancing urgent fixes with testing requirements for critical systems. 5. **Identify the Root Cause(s)**: By the fifth "Why" (or sometimes earlier or later), you often uncover a deeper systemic issue. In this example, the lack of a clear IT protocol represents a significant root cause, rather than just blaming CRM downtime. **Tallyfy Tip for 5 Whys:** When a problem is flagged in a [Tallyfy task comment](/products/pro/tracking-and-tasks/tasks/how-to-report-and-resolve-issues-in-tallyfy/), you can use the comment thread itself to conduct a collaborative 5 Whys session with your team. Each "Why" and its answer can be a reply in the thread, keeping the analysis in context. ### How does the Fishbone Diagram help identify problem causes? The Fishbone Diagram is a visual tool that helps teams brainstorm and categorize the potential causes of a problem. It's called a Fishbone because its structure resembles a fish skeleton. **How to create a simple Fishbone Diagram for office processes:** 1. **Define the Problem (The "Head")**: Write the problem statement at the "head" of the fish, on the right-hand side of your drawing space. 2. **Draw the "Spine"**: Draw a horizontal line extending to the left from the problem statement. 3. **Identify Major Cause Categories (The "Bones")**: Brainstorm broad categories of potential causes. For office processes, common categories might include: * **People**: Issues related to skills, training, communication, motivation. * **Process**: Problems with the workflow itself, unclear steps, handoffs, policies. * **Technology**: Issues with software, hardware, systems, data. * **Environment/Policy**: External factors, company policies, workspace issues. Draw diagonal lines (the main "bones") branching off the spine, labeling each with a category. 4. **Brainstorm Potential Causes**: For each major category, brainstorm specific potential causes related to the problem and list them as smaller "bones" branching off the main category bones. * *Example Problem*: Low customer satisfaction with support ticket resolution. * *People*: Insufficient training, high agent turnover. * *Process*: Too many handoffs, unclear escalation procedures. * *Technology*: Slow CRM system, knowledge base hard to search. 5. **Analyze and Investigate**: Once the diagram is populated, the team can discuss the potential causes, identify the most likely ones, and plan further investigation (perhaps using 5 Whys on the most probable causes or gathering data via Tallyfy Analytics). ### Visualizing the Fishbone Diagram This diagram shows how to structure root cause analysis using the Fishbone method to identify why support tickets aren't resolving satisfactorily. [Diagram removed for brevity] **What to notice:** - The problem statement (fish head) sits at the right, making it the focal point of analysis - Main categories branch off like bones, organizing causes into logical groups for systematic investigation - Specific causes connect to their categories, showing how individual issues contribute to the overall problem **Tallyfy Tip for Fishbone Diagrams:** While Tallyfy doesn't have a built-in Fishbone tool, you can create one collaboratively on a whiteboard (physical or virtual) and then attach a photo or summary of the diagram to a relevant Tallyfy task or process template description. The insights gained can inform improvements to your Tallyfy process. :::note[Collaborative Effort] Both the 5 Whys and Fishbone Diagrams are most effective when used as team exercises. Diverse perspectives help uncover a wider range of potential causes and lead to more robust solutions. ::: ### Advanced techniques for complex problems While 5 Whys and Fishbone work well for straightforward issues, complex problems may require more sophisticated approaches: #### Pareto analysis: focus on the vital few The Pareto Principle (80/20 rule) suggests that 80% of problems come from 20% of causes. This powerful insight helps prioritize improvement efforts. **How to conduct Pareto Analysis**: 1. **Collect data**: Track problem frequency over time (defect types, customer complaints, error categories) 2. **Sort by frequency**: Arrange causes from most to least frequent 3. **Calculate cumulative percentage**: Add percentages as you go down the list 4. **Identify the vital few**: Find where cumulative percentage reaches 80% **Example**: A call center analyzed customer complaints: - Wrong information provided: 45% of complaints - Long hold times: 25% - System errors: 15% - Attitude issues: 10% - Other: 5% The first two categories (70% combined) likely share root causes. Focusing here yields maximum impact. **Tallyfy Application**: Use form fields to categorize issues as they occur. Analytics automatically generates frequency data for Pareto analysis. #### Failure mode and effects analysis (FMEA): prevent before problems occur FMEA proactively identifies what could go wrong before it does. Originally from aerospace, it's invaluable for critical business processes. **Simple FMEA approach**: 1. **List process steps**: What could fail at each step? 2. **Rate three factors** (1-10 scale): - **Severity**: How bad if it fails? - **Occurrence**: How often might it fail? - **Detection**: How likely to catch before impact? 3. **Calculate Risk Priority Number (RPN)**: Severity × Occurrence × Detection 4. **Address highest RPNs first** **Example**: New employee onboarding - Step: "Send IT equipment" - Failure: Equipment arrives late - Severity: 8 (employee can't work) - Occurrence: 3 (happens occasionally) - Detection: 2 (hard to know until too late) - RPN: 48 - Action: Add tracking notifications and buffer time **Tallyfy Integration**: Build prevention into templates based on FMEA findings. Add checkpoints where high-risk failures might occur. #### Statistical thinking for service processes Numbers tell stories when you know how to listen. These techniques reveal patterns invisible to casual observation: **Run Charts**: Plot process performance over time. Look for: - Trends (6+ points moving same direction) - Shifts (8+ points on one side of average) - Patterns (repeating cycles) A loan processor noticed approval times spiked every Monday. Root cause? Weekend applications queued up, overwhelming Monday morning staff. Solution: Stagger Monday start times. **Scatter Diagrams**: Explore relationships between variables. Plot one factor against another to spot correlations. Example: Plot "training hours" against "error rates" for new employees. Strong negative correlation revealed 20+ hours training dramatically reduced errors - justifying investment in thorough onboarding. ### Choosing the right tool Match technique to problem complexity: **Use 5 Whys when**: - Problem is relatively simple - Need quick analysis - Single root cause likely **Use Fishbone when**: - Multiple causes possible - Need team brainstorming - Categories help organize thinking **Use Pareto when**: - Many problem types exist - Resources are limited - Need to prioritize efforts **Use FMEA when**: - Implementing new processes - Consequences of failure are severe - Prevention beats correction **Use statistical tools when**: - Data is available - Patterns aren't obvious - Need to prove relationships ### Making root cause analysis stick Knowledge without action is just trivia. Ensure your analysis drives real improvement: 1. **Document findings**: Attach RCA results to relevant Tallyfy processes 2. **Link to solutions**: Every root cause should connect to specific process changes 3. **Verify effectiveness**: Did addressing the root cause solve the problem? 4. **Share learnings**: Similar processes might have similar vulnerabilities By using these simple and advanced RCA techniques, you can move beyond quick fixes and address the underlying issues that impact your process performance. This leads to more effective and sustainable improvements managed through Tallyfy. - **[Streamlining change management](https://tallyfy.com/products/pro/tutorials/how-to/process-improvement/streamlining-change-management-with-tallyfy/)**: Change management in process improvement requires guiding people through transitions effectively and Tallyfy inherently simplifies this by involving users in suggesting improvements creating a single source of truth for processes enabling instant deployment providing built-in guidance reducing fear through incremental changes and maintaining transparency throughout the workflow transformation. ## Why change management matters in process improvement Successfully improving a process involves more than just designing a better workflow; it requires effectively managing the **transition for the people involved**. Resistance to change, lack of clarity, and insufficient training can derail even the most well-thought-out improvements. Effective **change management** is about guiding individuals, teams, and the organization from the current state to the desired future state smoothly and efficiently. While change can be challenging, Tallyfy has inherent features that streamline this often-difficult aspect of process improvement. ## Key challenges in managing process changes Traditionally, implementing process changes can face several hurdles: - **Resistance to Change**: People are naturally accustomed to their routines, and change can feel disruptive or threatening. - **Lack of Clear Communication**: If the reasons for change and the details of the new process aren't communicated well, confusion and opposition can arise. - **Insufficient Training**: Team members might not feel confident or equipped to perform tasks in the new way. - **Fear of the Unknown**: Ambiguity about what the change means for individuals can cause anxiety. - **Outdated Documentation**: SOP manuals become quickly outdated, leading to confusion about the correct current process. ### How Tallyfy inherently simplifies change management Many traditional change management challenges are inherently reduced or eliminated by how Tallyfy works: 1. **Involvement Reduces Resistance**: When users [suggest improvements via Tallyfy comments](/products/pro/tracking-and-tasks/tasks/how-to-report-and-resolve-issues-in-tallyfy/), they become part of the change process. This involvement fosters buy-in and reduces resistance because the changes are, in part, their own ideas. 2. **Clarity and a Single Source of Truth**: The updated [Tallyfy template *is* the new process](/products/pro/documenting/templates/). There are no separate SOP documents to distribute or conflicting versions. Everyone sees and executes the same, current standard process. *"Tallyfy removes the version control nightmare for processes. The live template is always the single source of truth." 3. **Instant and Unambiguous Deployment**: When you [edit a Tallyfy template](/products/pro/documenting/templates/edit-templates/), the changes are effective immediately for all new instances of that process. There's no confusion about when a new process takes effect or which version to use. 4. **Simplified Training and Guidance**: The Tallyfy task interface itself guides users through the new process. Clear, step-by-step instructions, checklists, and embedded media, can be built directly into the tasks. This often means users learn by doing, significantly reducing the need for extensive formal training sessions that [fail due to the forgetting curve](/products/pro/tutorials/why-documentation-training-fails-forgetting-curve/). 5. **Transparency and Visibility**: Everyone involved can see the process flow, their assigned tasks, and the status of work. This transparency reduces uncertainty and helps team members understand how their role fits into the bigger picture, even after changes. 6. **Reduced Fear Through Incremental Change**: Tallyfy makes it easy to implement small, incremental improvements (supporting a Kaizen approach). These smaller changes are generally less intimidating and easier for teams to adapt to than large, infrequent overhauls. :::note[Communicating Changes Effectively] While Tallyfy makes the *technical* deployment of changes easy, remember to still communicate the *why*. Use Tallyfy announcements, team meetings, or include a note in the updated template description to explain the reasons for the improvement and its benefits to the team and customers. ::: By integrating the process definition, execution, and documentation into a single platform, Tallyfy inherently addresses many of the traditional pain points associated with change management. It provides a clear, consistent, and easy-to-follow path for adopting improved workflows, allowing your team to focus on the benefits of the change rather than the difficulty of implementing it. - **[Understand process flow without flowcharts](https://tallyfy.com/products/pro/tutorials/how-to/process-improvement/understanding-process-flow-without-complex-flowcharts/)**: Tallyfy enables you to visualize and optimize how work flows through your organization by creating sequential templates that show real-time progress through tracker views and analytics which automatically reveal bottlenecks and delays without requiring complex flowcharts or diagrams. ## How can I visualize how work moves using Tallyfy templates? **Process flow** refers to the sequence of steps, activities, and handoffs that transform inputs into outputs to deliver value to a customer (internal or external). Understanding this flow is crucial for identifying bottlenecks, inefficiencies, delays, and areas for improvement. While traditional methods often involve creating complex diagrams, Tallyfy offers a more intuitive way to visualize and manage your workflow. ### Why is understanding process flow important? A clear view of your process flow helps you: - **Identify Bottlenecks**: Pinpoint where work piles up or slows down, constraining the entire process. - **Spot Delays and Queues**: See where tasks wait for extended periods before being actioned. - **Recognize Inefficient Handoffs**: Understand if transitions between team members or departments are smooth or problematic. - **Eliminate Unnecessary Steps**: Identify activities that don't add value and can be removed. - **Improve Overall Efficiency**: Streamline the path work takes, reducing overall cycle time. ### How does Tallyfy's approach compare to traditional flowcharts? Tools like detailed flowcharts and Value Stream Maps (VSMs) are traditionally used to map out process flow. These can be very powerful, especially in complex manufacturing settings. However, for many office and service-based processes, they can be overly complicated to create, maintain, and for the average business user to understand. **Tallyfy simplifies understanding process flow:** 1. **Define Sequentially**: When you [create a template in Tallyfy](/products/pro/documenting/templates/edit-templates/), you are inherently defining the process flow. Each step follows the previous one, with clear assignments and (optional) deadlines. 2. **Visualize in Action**: Once a [process is launched](/products/pro/launching/), the **[Tracker view](/products/pro/tracking-and-tasks/tracker-view/)** and the individual **[process status page](/products/pro/tracking-and-tasks/tracker-view/how-can-i-manage-and-track-my-processes-on-tallyfy/)** provide a real-time visual of where things stand. You see completed steps, the current active step, and upcoming steps. 3. **Handoffs are Clear**: Task assignments clearly indicate who is responsible for each part of the flow. When one person completes their task, it automatically (or based on rules) moves to the next assignee. ### How can I identify flow issues in Tallyfy? Because your processes are live and tracked in Tallyfy, identifying flow problems becomes much easier: - **Use the [Tracker View](/products/pro/tracking-and-tasks/tracker-view/)**: This Kanban-style board provides a bird's-eye view of all active processes. Look for columns (steps) where many tasks are piling up – these are your bottlenecks. - **Use [Tallyfy Analytics](/products/pro/integrations/analytics/)**: Dive into the data to see: - Average time spent on each step: Steps with significantly longer durations are potential constraints. - Overdue tasks: A high concentration of overdue tasks at a particular step indicates a flow problem. - **Monitor [Task Comments](/products/pro/tracking-and-tasks/tasks/how-to-report-and-resolve-issues-in-tallyfy/)**: Frequent comments about delays, waiting for information, or confusion at a specific step are qualitative indicators of flow issues. ### What simple strategies can improve process flow in Tallyfy? Once you've identified areas for improvement, Tallyfy makes it easy to adjust the flow: - **Reorder Steps**: If a sequence is illogical or causing delays, simply drag and drop steps in your template editor. - **Clarify Instructions**: Ambiguity causes delays. Ensure instructions within Tallyfy tasks are crystal clear. - **Use [Conditional Logic (Rules)](/products/pro/documenting/templates/automations/logic-explained/)**: Automate routing to bypass unnecessary steps based on specific criteria, ensuring work only goes where it needs to. - **Optimize Handoffs**: Ensure that when a task moves from one assignee to another, all necessary information is readily available in the Tallyfy task. This minimizes delays caused by information seeking. - **Consider Parallel Steps**: If certain activities can happen simultaneously rather than sequentially, configure them as parallel steps in Tallyfy to speed up the overall process. Understanding and optimizing process flow doesn't have to be a complex, diagram-heavy exercise. By using Tallyfy to clearly define, execute, and monitor your workflows, you gain inherent visibility into how work moves. This enables you to readily identify and address inefficiencies to keep things flowing smoothly. - **[Understanding your current processes](https://tallyfy.com/products/pro/tutorials/how-to/process-improvement/understanding-your-current-processes-with-tallyfy/)**: Documenting existing workflows serves as the essential foundation for process improvement by providing clarity and consistency for teams while creating a baseline for measuring enhancements and revealing inefficiencies through structured documentation tools like Tallyfy that eliminate complex flowcharts and maintain living documentation. ## Why is documenting existing workflows the starting point? Effective process improvement always begins with a clear understanding of your current state. After all, you can't effectively improve what you don't thoroughly understand. Many office workflows suffer from being undocumented, vaguely defined, or existing only as "tribal knowledge" passed down informally. This lack of clarity creates a major barrier to improvement. ### Why should I document my processes? Taking the time to make your processes explicit offers several key advantages: - **Clarity and Consistency**: Everyone knows the right way to do things, leading to more consistent outcomes. - **Effective Training**: Documented processes are invaluable for onboarding new team members quickly. - **Baseline for Improvement**: A clear "as-is" process provides the foundation upon which improvements can be measured and built. - **Identifying Inefficiencies**: Often, the very act of documenting a process reveals redundancies, bottlenecks, or unnecessary steps. Traditionally, this involved creating detailed flowcharts or process maps. While these can be useful, they often become complex, quickly outdated, and are typically created by specialists. This makes them less accessible to the people actually doing the work. ### What advantages does Tallyfy offer for understanding processes? Tallyfy offers a refreshingly modern and straightforward way to understand and document your processes: - **No complex flowcharts needed**: With Tallyfy, you don't need to be a flowchart expert. You define your process by simply listing the steps in order, assigning roles, adding rules, and embedding instructions. The Tallyfy template *becomes* your process map – clear, actionable, and easy for anyone to understand. - **Living documentation**: Unlike static documents that gather dust, Tallyfy templates are dynamic. When you run a process from a template, you're executing the live, current version. This means your documentation remains always up-to-date. - **AI-powered process capture**: Getting started becomes even easier with Tallyfy's AI capabilities. You can describe a process in plain language, or even upload existing documents (like old Word files or checklists), and Tallyfy's AI will help generate a first draft of your process template. This overcomes the "blank page" hurdle and gets your process into a structured format quickly. :::tip[Visualize your workflow with "Process Stapling"] Imagine an order or a request physically moving through your office. "Process Stapling" is a technique where you mentally (or even physically, with a printout) follow that item from start to finish, noting every person it touches and every action taken. As you do this, you can directly input these steps into a Tallyfy template, quickly capturing the real flow of work. ::: ### What key information should I capture in Tallyfy? As you document your existing processes in Tallyfy, think about the core components of any workflow. A simple framework like **SIPOC** (Suppliers, Inputs, Process, Outputs, Customers) can help, even without formal diagramming: - **Process Steps**: These are the individual tasks in your Tallyfy template. - **Inputs**: What information, documents, or resources are needed for each step? These can be captured in Tallyfy form fields or as attachments. - **Outputs**: What does each step produce? What is the final outcome of the process? - **Suppliers (of inputs)**: Who or what system provides the inputs for each step? - **Customers (of outputs)**: Who receives the output of each step, and who is the ultimate customer of the overall process? - **Roles and Responsibilities**: Tallyfy's assignee feature makes it clear who is responsible for each step. By structuring your template in Tallyfy, you inherently define who does what, when, and with what information. This clarity itself is a form of process understanding. ### How can I gain initial insights from process documentation? Once your process is documented in a Tallyfy template, even before launching it, you and your team can often spot initial pain points or areas needing clarification. Reviewing the steps, assignees, and embedded instructions can spark immediate discussions. :::note[Use comments for early feedback] As you're documenting an existing process into a Tallyfy template, encourage your team to use the **comment feature** on steps where they have questions, notice inconsistencies with current practice, or see immediate small improvement opportunities. This captures valuable insights right from the start. ::: Understanding your current processes serves as the bedrock of any successful improvement effort. Tallyfy simplifies this crucial first phase, empowering you to move quickly from undocumented workflows to clear, actionable, and improvable processes. - **[What is process improvement?](https://tallyfy.com/products/pro/tutorials/how-to/process-improvement/what-is-process-improvement/)**: Process improvement is a systematic approach to analyzing and enhancing current workflows to increase efficiency reduce errors improve customer satisfaction lower costs boost employee morale and strengthen competitive advantage through tools like Tallyfy that make processes visible trackable and easily modifiable. ## What is process improvement and what are its benefits? Do you ever feel like you're running hard but not always moving forward efficiently? Perhaps your team is bogged down by repetitive tasks, frustrating delays, or recurring errors. These are often symptoms of processes that could be working much better. That's where **process improvement** comes in. At its heart, a **process** is simply a series of steps or actions taken in a specific order to achieve a particular outcome. Whether it's onboarding a new client, handling a customer support request, or generating a monthly report, your organization runs on processes. **Tallyfy process improvement** is the systematic approach of analyzing your current processes (the "as-is" state) and implementing changes to make them more effective, efficient, and aligned with your business goals and customer needs (the "to-be" state). This involves asking, "How can we do this better?" ### Why is process improvement so important? Investing time and effort into improving your processes isn't just a box-ticking exercise. It delivers tangible benefits that can transform your business: - **Increased efficiency and productivity**: Streamlined processes mean less wasted time and effort. Imagine your team spending less time on manual data entry for client onboarding because Tallyfy automates parts of it, freeing them up for higher-value work. - **Improved quality and reduced errors**: Well-defined and optimized processes minimize mistakes. For instance, a clear, step-by-step process in Tallyfy for generating financial reports can significantly reduce calculation errors or missed data points. - **Enhanced customer satisfaction and loyalty**: Faster, more reliable, and error-free service leads to happier customers. When your customer support process is improved to resolve issues quicker and more consistently (tracked in Tallyfy, of course!), customers are more likely to stay loyal. - **Reduced costs**: Efficiency gains and error reduction directly translate to cost savings. Less rework, fewer wasted materials (even in an office, think wasted paper or time), and optimized resource allocation all contribute to a healthier bottom line. - **Better employee morale and engagement**: When processes are clunky and frustrating, employees suffer. Clear, efficient processes managed in a tool like Tallyfy can reduce stress and allow employees to focus on meaningful work, boosting morale and engagement. - **Increased agility and competitiveness**: Businesses that continuously improve their processes can adapt more quickly to market changes and customer demands, giving them a significant competitive advantage. ### How does process improvement work beyond the factory floor? Many foundational process improvement concepts, like Lean and Six Sigma, originated in manufacturing. However, their principles are universally applicable and incredibly powerful in office environments and professional services. Think of your workflows like a city's road system. When roads (processes) are poorly designed, full of potholes (errors), and have confusing signage (unclear instructions), traffic (work) gets snarled, deliveries (outcomes) are late, and drivers (employees and customers) become frustrated. Process improvement is like upgrading that road system to ensure smooth, efficient, and reliable journeys for everyone. In an office, "waste" might not be piles of scrap metal, but it could be wasted time searching for information, unnecessary approval steps, or duplicated data entry. Tallyfy helps you make these office processes visible and manageable, which is the essential first step to identifying and eliminating such waste. ### How does Tallyfy champion process improvement? Tallyfy is designed from the ground up to support your process improvement initiatives. By making your processes explicit, trackable, and easy to modify, Tallyfy creates a dynamic environment where improvements can be readily identified, implemented, and sustained. Throughout this guide, we'll explore specific methodologies and techniques, always highlighting how Tallyfy's features can help you implement them effectively. The journey to better processes begins with understanding them, and Tallyfy helps you see your processes clearly – the crucial first step to making them better. ### Features - **[Customer facing](https://tallyfy.com/products/pro/tutorials/features/customer-facing/)**: Tallyfy's Guest feature allows external stakeholders like customers vendors and partners to participate in workflows through secure email links without needing accounts while maintaining professional branding and unlimited free access. ## How can I work with external guests in Tallyfy? Tallyfy's **Guest** feature enables seamless external stakeholder participation in workflows without requiring account creation or password management. This capability allows easy involvement of customers, clients, vendors, partners, and other external collaborators in your Tallyfy business processes. The system maintains security while simplifying access for non-internal users. ### What key features does Tallyfy provide for guest collaboration? * **No login needed**: Guests access their assigned [tasks](/products/pro/tracking-and-tasks/tasks/) through a unique, secure link sent via email. No account creation or password required. * **One link per person**: Each guest email (e.g. jane.doe@gmail.com) maps to one specific link that never changes. They can access all tasks assigned to their email address via this single link (after verifying their email the first time). * **Your branding**: Guests see your company logo and colors for a professional look. * **Guests can reassign**: When needed, a guest can pass their task to someone else on their team by adding the new person's email. * **Unlimited & Free**: Invite as many guests as needed at no extra cost. * **Automatic reminders**: Guests receive automatic email reminders for upcoming or overdue tasks. They can adjust the reminder frequency. Using guests allows smooth collaboration with external people on specific tasks without granting them full access to your Tallyfy organization. - **[Explain it once](https://tallyfy.com/products/pro/tutorials/features/explain-it-once/)**: Tallyfy templates implement the "Explain it Once" philosophy by allowing organizations to define standard processes once and execute them consistently across all teams with features like AI-assisted creation document conversion multilingual support device compatibility compliance tracking continuous improvement capabilities and conditional logic to eliminate repetitive explanations and ensure uniform workflow execution. ## How does "Explain it Once" work with Tallyfy templates? ![Explain it once visualized as a single person speaking into a megaphone on the left with their message transforming into multiple identical template copies flowing to different team members on the right - representing standardized processes explained once and executed consistently](https://screenshots.tallyfy.com/illustrations/explain-it-once.jpeg) Tallyfy templates embody the powerful "Explain it Once" philosophy. This lets organizations define standard processes once and execute them consistently across all teams. This Tallyfy approach makes sure your organization stays consistent while getting rid of repetitive process explanations. Teams follow identical standardized processes every time they're needed. This cuts down on training time and prevents workflow variations that can hurt quality and efficiency. ### What template creation methods and features does Tallyfy provide? Tallyfy gives you full template creation capabilities and supporting features designed for diverse organizational needs and requirements: * **AI-assisted creation**: Get help building templates using Tallyfy AI, especially when you're starting from scratch. * **Document conversion**: Upload existing Word docs, PDFs, or flowcharts, and Tallyfy AI will try to convert them into digital templates. * **Multilingual support**: Translate template content automatically for global teams using the [Azure AI integration](/products/pro/integrations/azure-translation/). Organizations operating internationally should review [global workplace language requirements](/products/pro/integrations/azure-translation/global-workplace-language-requirements/) to ensure compliance with local regulations. * **Works on any device**: Templates and processes automatically adjust to look good and work well on desktops, tablets, and phones. * **Compliance support**: Track who did what and when with audit trails, and control permissions to meet regulations. * **Continuous improvement**: Use built-in comments to collect feedback and easily update templates. * **Template maintenance**: Set reminders or tasks for regularly reviewing and updating templates. * **Analytics integration**: Connect to tools like Google [Analytics](/products/pro/integrations/analytics/) to track template usage. * **Conditional logic**: Build smart templates using "if-this-then-that" rules ([Automations](/products/pro/documenting/templates/automations/)) that adapt to different situations. - **[Fill in the blanks](https://tallyfy.com/products/pro/tutorials/features/fill-in-the-blanks/)**: Tallyfy enables users to create smart document templates with fixed standard text and customizable blank fields that automatically populate with previously collected data through variables and reusable snippets instead of manually copying and editing old documents. ## How can I stop cloning docs and use fill-in-the-blanks templates? ![Fill in the blanks visualized as a document template on the left with highlighted editable fields transforming into a completed professional document on the right - showing how smart templates combine fixed standard text with customizable blank fields](https://screenshots.tallyfy.com/illustrations/fill-in-blanks.jpeg) Instead of copying old documents (like contracts) and manually changing details, Tallyfy workflow management lets you create smart **[Document Templates](/products/pro/documenting/documents/)**. ### How can I set what people can change? With a document template, you define the standard text that *shouldn't* change. Then, add specific editable [fields (blanks)](/products/pro/documenting/documents/how-can-i-add-editable-fields-to-my-tallyfy-documents/) where users enter custom information (like a client name or date). When someone uses the document template, they fill in the defined blanks. The rest stays consistent across all documents. ### How can I reuse standard text blocks with snippets? When you have standard paragraphs (like legal text or company info) used in many documents, create a [**Snippet**](/products/pro/documenting/templates/snippets/) with that text. You can insert that snippet into multiple document templates. When the standard text changes, edit the snippet *once*, and the update automatically appears everywhere it's used. ### How can I pull in data automatically using variables? When you collected information earlier in a process (like a customer name), use [**_Variables_**](/products/pro/documenting/templates/variables/) to insert that data automatically into your document template. This means data is entered only once but can appear in multiple places. This reduces errors and saves time (especially great for contracts). - **[If-this-then-that](https://tallyfy.com/products/pro/tutorials/features/if-this-then-that/)**: Tallyfy uses intuitive if-this-then-that automation rules that allow business users to create intelligent workflow logic without programming knowledge by setting up conditions that automatically trigger actions like changing assignments hiding steps or adjusting deadlines based on user inputs and process states. ## How do if-this-then-that rules work in Tallyfy? ![If-this-then-that automation visualized as a decision tree with conditional branches on the left flowing to different automated actions on the right - showing how simple rules create intelligent workflow behavior without complex flowcharts](https://screenshots.tallyfy.com/illustrations/create-automation.jpeg) Tallyfy uses intuitive "If-this-then-that" rules, also known as Automations or conditional logic, to automate intelligent decisions and actions within your processes. These Tallyfy automation rules enable dynamic workflow behavior that responds intelligently to changing conditions, user inputs, and process states. This gets rid of the need for manual intervention or complex programming knowledge. ### Why does Tallyfy use simple rules instead of flowcharts? Complex flowcharts often confuse business users and process managers and are hard to maintain. Tallyfy's clear if-this-then-that statements give you better usability and management capabilities. These stay accessible to all team members, even when handling sophisticated workflow scenarios that need multiple conditional branches. ### How accessible are Tallyfy's automation rules? Tallyfy's automation interface doesn't need any programming expertise. This lets business users create sophisticated conditional logic through intuitive configuration options. Users can easily set up complex business rules such as "IF the amount exceeds $500, THEN display the manager approval step" without technical knowledge or coding requirements. ### How can business teams manage their own rules? Teams can often adjust their own workflow logic without needing IT help every time they need a change. ### How does Tallyfy connect to other tools? While the rules are simple to create, they can trigger actions in other systems using Tallyfy's integration options like the API, Middleware, or Webhooks. ### What actions can if-this-then-that rules trigger? These if-this-then-that rules can trigger various actions: * Change task assignments. * Adjust task deadlines. * Show or hide steps. * Re-open completed tasks. ### How can I convert existing flowcharts? When you have existing flowcharts, Tallyfy offers tools (like AI import) to help turn them into runnable Tallyfy templates. - **[Migration guide](https://tallyfy.com/products/pro/tutorials/features/migrate-to-tallyfy/)**: Tallyfy provides open-source migrator scripts that help users move data from popular workflow and form tools through a five-phase process including discovery mapping transformation migration and validation with support for platforms like Asana Basecamp ClickUp Google Forms Monday.com Pipefy Process Street Trello and many others. ## How do I migrate data from other platforms to Tallyfy? You can move from many popular workflow and form tools into Tallyfy using our open-source migrator scripts. Start with a dry run, review the report, then run the full migration when you're ready. The code lives here: [Tallyfy Migrator on GitHub](https://github.com/tallyfy/migrator)[1]. :::note[Important] We provide these scripts as-is under the MIT license. Test with `--dry-run`, understand the caveats per vendor, and validate results before production use. ::: ### What does the migrator do? The migrator runs a five-phase flow that matches how data moves from a source vendor into Tallyfy: - **Discovery**: Connects to the source, catalogs available data, and gathers counts. - **Mapping**: Translates vendor concepts to Tallyfy concepts (for example, project → template, task → step/task, custom field → form field). - **Transformation**: Converts structures to Tallyfy format and prepares users, fields, and metadata. - **Migration**: Creates data in Tallyfy. Supports dry-run and checkpoint resume. - **Validation**: Verifies integrity and outputs a report you can keep. ## How to run a migration (recommended path) ## Vendor-by-vendor notes and caveats Each folder below links directly to the open-source code for that vendor, with a quick summary of scope and common considerations. - **Asana**: [Folder](https://github.com/tallyfy/migrator/tree/main/asana)[2] - **Scope**: Projects, tasks/subtasks, sections, custom fields → map to Tallyfy templates, steps, and form fields. - **Caveats**: Dependencies and sections may flatten or translate into conditional steps. Tags often become metadata. Respect API rate limits. - **Basecamp**: [Folder](https://github.com/tallyfy/migrator/tree/main/basecamp)[3] - **Scope**: To-dos and lists → procedure templates and steps; message docs are typically referenced via links. - **Caveats**: Threads/comments are not 1:1 with Tallyfy task comments; attachments may be copied by URL. - **ClickUp**: [Folder](https://github.com/tallyfy/migrator/tree/main/clickup)[4] - **Scope**: Lists/folders/spaces, tasks, custom fields. - **Caveats**: Deep hierarchy is flattened into templates and steps. Use rules-based flattening; consider AI mapping for complex setups. - **Cognito Forms**: [Folder](https://github.com/tallyfy/migrator/tree/main/cognito-forms)[5] - **Scope**: Forms and submissions → kick-off forms and variables. - **Caveats**: Field validation and conditional logic translate to Tallyfy where possible; verify complex branching. - **Google Forms**: [Folder](https://github.com/tallyfy/migrator/tree/main/google-forms)[6] - **Scope**: Questions and responses. - **Caveats**: Simple structure migrates well; logic jumps may require manual checks. Low complexity. - **Jotform**: [Folder](https://github.com/tallyfy/migrator/tree/main/jotform)[7] - **Scope**: Forms, fields, and submissions. - **Caveats**: Rich widgets may need custom mapping. Watch for attachment handling and rate limits. - **Kissflow**: [Folder](https://github.com/tallyfy/migrator/tree/main/kissflow)[8] - **Scope**: Workflows and forms. - **Caveats**: Some constructs (like advanced states) may map to conditional steps or automations; review validation results carefully. - **Monday.com**: [Folder](https://github.com/tallyfy/migrator/tree/main/monday)[9] - **Scope**: Boards, groups, items, column types. - **Caveats**: 30+ field types via GraphQL. Use AI for field mapping where possible. High complexity; test thoroughly. - **Next Matter**: [Folder](https://github.com/tallyfy/migrator/tree/main/nextmatter)[10] - **Scope**: Processes and tasks. - **Caveats**: Step logic and automations may need manual review. Confirm user-role mapping. - **Pipefy**: [Folder](https://github.com/tallyfy/migrator/tree/main/pipefy)[11] - **Scope**: Pipes, phases, fields. - **Caveats**: Paradigm shift from card/connection model to templates/steps. Use AI for workflow conversion. High complexity. - **Process Street**: [Folder](https://github.com/tallyfy/migrator/tree/main/process-street)[12] - **Scope**: Checklists, tasks, conditional logic. - **Caveats**: Complex conditions translate to Tallyfy automations. Medium complexity; validate branching. - **Rocketlane**: [Folder](https://github.com/tallyfy/migrator/tree/main/rocketlane)[13] - **Scope**: Project templates and tasks. - **Caveats**: Timeline and resource views do not directly map; focus on steps and assignments. - **Trello**: [Folder](https://github.com/tallyfy/migrator/tree/main/trello)[14] - **Scope**: Boards, lists, cards → templates and steps. - **Caveats**: Checklists and labels map to steps/metadata. Butler automations require manual recreation. - **Typeform**: [Folder](https://github.com/tallyfy/migrator/tree/main/typeform)[15] - **Scope**: Forms and responses. - **Caveats**: Logic jumps translate where feasible. Low complexity overall. - **Wrike**: [Folder](https://github.com/tallyfy/migrator/tree/main/wrike)[16] - **Scope**: Projects/folders, tasks, custom fields. - **Caveats**: Folder/project distinctions flatten into template/process structure. Validate dependencies and custom field mappings. ## Prerequisites - Python 3.10+ and `pip` installed - Tallyfy credentials: `TALLYFY_API_KEY` and `TALLYFY_ORGANIZATION` - Source vendor API credentials - Sufficient disk space for logs and reports ## Tips, validation, and troubleshooting - **Always dry-run first.** Review the migration report. Fix obvious mapping gaps before moving on. - **Mind rate limits.** Tune `MIGRATION_RATE_LIMIT_DELAY` and batch sizes for large datasets. - **Use checkpoints.** For long runs, `--resume` saves time after transient failures. - **AI assistance helps.** For complex vendors (Monday.com, Pipefy), enable AI mapping to improve field translations. - **Verify outcomes.** Spot-check templates, steps, users, and sample processes in Tallyfy after migration. ## Where this lands in Tallyfy Migrated structures typically become Tallyfy [templates](/products/pro/documenting/templates/), then you [launch processes](/products/pro/launching/) you can track as live [processes](/products/pro/tracking-and-tasks/processes/) with individual [tasks](/products/pro/tracking-and-tasks/tasks/). Use [automations](/products/pro/documenting/templates/automations/) to recreate conditional behavior from the source system. - **[Real time status](https://tallyfy.com/products/pro/tutorials/features/real-time-status/)**: Tallyfy provides real-time process status visibility through automatic live monitoring that eliminates manual status checking and replaces time-consuming status meetings with instant package-tracking-style visibility into workflow progress and task completion. ## How does Tallyfy provide real-time process status visibility for workflow management? ![Real-time status visualized as a control room dashboard on the right showing live workflow progress with green indicators and completion percentages, contrasted with a frustrated person on the left surrounded by question marks and disconnected status reports](https://screenshots.tallyfy.com/illustrations/real-time-status.jpeg) Tallyfy gives you automatic, live status monitoring for all running processes. This gets rid of manual status checking and cuts down on admin work big time. Tallyfy real-time status visibility changes the game for workflow management by giving you instant access to current process states. This cuts down on time spent asking for updates and **gets rid of status meetings** entirely. ### How does real-time tracking eliminate status meetings? Traditional workflows depend on frequent status meetings where managers ask "What have you done? What are you doing? What's the status of this?" These meetings happen partly because people forget process details due to the forgetting curve. Tallyfy's real-time visibility makes these meetings a thing of the past: **Instead of status meetings, you get:** - **Package tracking for workflows**: Just like tracking a FedEx package or Domino's pizza delivery, you can see exactly where each process stands without asking anyone - **Olympic relay race visibility**: Clear view of who has the "baton" and what's coming next in the workflow sequence - **Two hours per day saved**: Studies show teams spend approximately two hours daily on "busy work" - asking people about status and progress - **"Don't ask me that again" transparency**: Process owners can direct people to check the real-time tracker instead of fielding status questions **Real-world impact:** - **No more status chasing**: "Are you done yet?" becomes "let me check the tracker" - **Instant progress visibility**: See who's late, who's on track, and what's coming next without meetings - **Mistake-proof accountability**: Tasks sit visibly in the system until completed - "I forgot" is no longer possible - **Baton-passing clarity**: Like a relay race, you can see exactly when one person finishes and the next begins This transparency lets managers and team members stay in the loop without constant interruptions or status requests throughout their workday. ### How does automatic progress tracking work for seamless monitoring? Tallyfy's intelligent progress tracking system instantly updates process status whenever team members complete tasks. This provides immediate workflow visibility across the organization. This automated tracking enables clear visualization of completed work, active tasks, and upcoming activities. Manual status updates through email or chat communications are no longer required. The system eliminates information delays and ensures everyone has access to current, accurate workflow status throughout their projects. ### How do automatic notifications keep workflows moving efficiently? Tallyfy's notification system automatically alerts team members when tasks become available for their action. Notifications are delivered through email and in-app channels for maximum reach. Automated notifications eliminate manual follow-up requirements while ensuring continuous workflow momentum through timely task assignment alerts. This proactive communication prevents workflow stalls and maintains consistent process velocity without requiring management intervention. ### How does Tallyfy enable easier analysis and continuous improvement? Because Tallyfy uses standard templates, tracking how long processes and steps take becomes much more consistent than using emails or spreadsheets. This consistency helps you: * Compare different runs of the same process for performance patterns. * Spot bottlenecks or steps causing delays for targeted optimization. * Measure whether changes actually improve the process with concrete data. * Make better decisions using real data rather than assumptions. This data-driven approach enables continuous process improvement based on actual performance metrics rather than subjective assessments. ### How does Tallyfy deliver more predictable results? Using documented, trackable processes in Tallyfy leads to more consistent outcomes compared to managing work through scattered emails or simple to-do lists. This consistency stems from standardized workflows, clear accountability, and systematic execution. This approach eliminates the variability inherent in ad-hoc work management approaches. - **[Structure intake](https://tallyfy.com/products/pro/tutorials/features/structure-intake/)**: Tallyfy's integrated form and process management connects intake forms directly to workflow steps creating end-to-end visibility and accountability by automatically starting trackable processes when forms are submitted and maintaining data continuity throughout the entire sequence. ## How does integrated form and process management work? Tallyfy connects [forms](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) with the later workflow [steps](/products/pro/tracking-and-tasks/processes/). This creates Tallyfy visibility and accountability through the whole sequence from submission to completion. This turns separate form submissions into the first step of a structured, trackable process. ### How does form-to-process integration work? The platform connects intake forms directly to later steps by: - Placing kick-off forms at the start of process [templates](/products/pro/documenting/templates/). - Automatically starting defined workflows when a form is submitted. - Tracking progress through all following steps. - Making the entire process visible to relevant people. - Including external participants using [guest access](/products/pro/documenting/guests/). As [work intake software](https://tallyfy.com/solutions/work-intake-software/), Tallyfy ensures all incoming requests are captured, routed, and tracked properly from start to finish. ### How does Tallyfy provide visibility throughout the process lifecycle? Unlike separate forms where visibility stops after submission, Tallyfy provides ongoing status tracking for everyone involved (internal and external). This eliminates the need for manual follow-ups about submission status. ### How does data continuity work throughout processes? Information collected in kick-off forms is available throughout the process: - [Form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) data flows automatically to later steps. - [Variables](/products/pro/documenting/templates/variables/) can pull form field values into later steps. - [Webhooks](/products/pro/integrations/webhooks/) can send form data to other systems. - All submitted info remains accessible to authorized people. ### How does submission verification work? The system has validation features that help ensure real submissions: - Email verification for external guests. - Secure access control through verified email links. - Options for public access forms when needed. ### What form migration options are available? You can migrate existing forms (web forms, Word/Excel/PDF docs, paper forms) into Tallyfy. Available conversion tools help with the migration process. - **[Tickets vs. Processes](https://tallyfy.com/products/pro/tutorials/features/ticket-driven-vs-process-driven/)**: Ticket-driven workflows operate through separate communication channels like email phone calls and chat messages that follow a basic sequence of queue management initial assessment information gathering issue resolution and optional improvements while process-driven models enhance operations by providing structured intake automated routing systematic knowledge application clear collaboration protocols and continuous improvement connections that create consistent scalable and transparent workflow management. ## How do ticket-driven workflow models operate? ![Comparison of ticket-driven chaos versus process-driven clarity - left side shows tangled wires and scattered papers representing ad-hoc tickets, right side shows organized flowing pathways representing structured processes](https://screenshots.tallyfy.com/illustrations/ticket-driven-vs-process-driven.jpeg) Ticket-driven workflows often work like separate conversations started in different ways: * Email to a specific address for formal requests * A new social media conversation for public inquiries * A phone call for urgent matters * A chat message on a website or app for immediate assistance :::warning[The shared inbox problem] Shared inboxes suffer from the same fundamental flaws as ticket systems - they're unstructured chaos masquerading as organization. Teams dump emails into a shared inbox hoping someone will handle them, but what you get is: - **No structured data**: Just walls of text with information buried in email threads - **No accountability**: "Someone" will handle it (but who? when?) - **No visibility**: Is this being worked on? Who knows? - **No consistency**: Each person handles requests their own way - **No improvement**: Same problems repeat because there's no process to optimize Both tickets and shared inboxes are fundamentally about opening and closing something with minimal structure - they're Band-Aids on broken processes. ::: The typical ticket workflow follows this sequence: 1. **Managing the queue**: An incoming request waits to be processed in order. 2. **Initial check**: An agent decides if they can handle it or if it needs a specialist team. 3. **Gathering information**: Collecting more details if the initial info isn't enough for resolution. 4. **Solving the issue**: Responding and providing a solution to close the ticket. 5. **Optional check for root cause**: Looking into underlying problems that might need fixing in the product. 6. **Optional feature consideration**: Deciding if the issue suggests possible product improvements. 7. **Optional help docs update**: Checking if documentation needs updating based on the question. This model often has several operational downsides: * Steps 5-7 are often skipped due to time constraints or lack of process enforcement. * Customers can't easily see the ticket status or progress, creating uncertainty. * Manual follow-up is needed if responses are slow, increasing administrative overhead. * Service quality depends heavily on the individual agent handling the ticket, creating inconsistency. ## How do process-driven workflow models enhance operations? Tallyfy process-driven workflows turn ticket handling into structured processes with clear steps and accountability. Key features include: * **Structured intake**: Using standard forms for initial request details and categorization for consistency. * **Routing before review**: Automatically sending requests to the right teams based on type for efficiency. * **Using help docs automatically**: Applying knowledge base info systematically for consistent responses. * **Involving other teams**: Clearly defining when other departments get involved for seamless collaboration. * **Linking to improvement processes**: Connecting issues systematically to product improvement workflows for continuous enhancement. This approach transforms reactive ticket handling into proactive workflow management. ## What advantages do process-driven workflows provide over ticket systems? * **Consistent steps**: Standard handling for all interactions ensures uniform quality. * **Ensuring follow-up**: Automated reminders prevent missed steps and maintain accountability. * **Processes that can grow**: Clear ownership and next steps enable easy scaling as volume increases. * **Clear progress tracking**: Visual status updates keep everyone involved informed of current state. * **Customer visibility options**: Optionally showing process status to external people for transparency. * **Regular improvement cycles**: Structured review of recurring issues drives systematic product improvement. * **Improving help docs**: Systematically reviewing if help documentation is adequate for self-service. :::tip[The power of structured funnels: Before, During, and After] Replacing tickets with structured processes creates immense advantages by building a complete funnel that captures value at every stage: **BEFORE (Structured Intake)**: - **Kick-off forms** collect exactly the data you need - no more, no less - Required fields ensure critical information isn't missing - Dropdown menus, date pickers, and validation prevent garbage data - Conditional logic shows/hides fields based on previous answers - File upload fields capture supporting documents upfront **DURING (Structured Execution)**: - Every step has clear ownership and deadlines - Automated routing based on form data (no manual triage) - Parallel processing when multiple teams need to work simultaneously - Form fields at each step capture structured progress data - Comments stay attached to specific steps, not lost in email threads - Real-time visibility shows exactly where things stand **AFTER (Structured Outcomes)**: - Completion data feeds directly into analytics - Structured output enables automatic downstream actions - Performance metrics are automatically captured - Process improvements are data-driven, not guesswork - Knowledge base updates happen systematically - Customer feedback links to specific process steps **The Bottom Line**: Tickets and shared inboxes give you a mess of unstructured text. Processes give you clean, structured data flowing through a predictable funnel. Which would you rather scale? ::: These advantages create more reliable, scalable, and customer-friendly support operations compared to traditional ticket-driven approaches. ### Integrations - **[Extract tasks from meetings](https://tallyfy.com/products/pro/integrations/extract-tasks-from-meetings/)**: Tallyfy is developing an AI-powered feature that automatically converts meeting recordings into actionable tasks by transcribing conversations identifying task assignments through voice recognition and creating structured tasks with full context while using a Draft state review system to ensure accuracy before tasks become active. ## Converting meeting recordings into actionable tasks ## The meeting productivity problem Your team just finished an hour-long meeting. Six people agreed to do twelve different things. By next week? Three tasks get done, five are forgotten, and four were misunderstood. Sound familiar? Here's the reality - meetings generate tons of actionable work, but without proper tracking, those action items vanish into the ether. You've probably experienced this cycle: multiple meetings about the same project where people ask "wait, who was supposed to do that?" because nobody tracked the tasks from the last meeting. It's exhausting. Extracting actionable tasks from meetings manually takes significant time. Teams using basic transcription often miss important action items. And when tasks aren't properly assigned with clear owners and deadlines? They simply don't get done. ## How Tallyfy will solve this We're building a smart integration that connects your meeting platform (Zoom, Teams, Google Meet) directly to Tallyfy's task management system. Record your meeting as usual. Tallyfy handles the rest. The system transcribes your meeting using state-of-the-art AI that works with multiple languages. But transcription is just the beginning. The real magic happens when our AI analyzes the conversation to identify who committed to what - and when they'll deliver it. ### Identity recognition that actually works "John, can you send the proposal to the client by Friday?" Simple for humans to understand. Surprisingly complex for AI. Our system identifies both the task creator (the person asking) and the assignee (John) using Single Sign-On (SSO) integration. When your team logs into both the meeting platform and Tallyfy with the same SSO provider, we automatically match voices to user profiles. John gets assigned the task. The person who asked becomes the task creator. No manual mapping needed. What if someone joins as a guest or SSO isn't configured? The system creates placeholder assignments that you can map to real users during the review phase. We never lose track of who said what. ### Rich task context, not just titles A task titled "Send proposal" tells you nothing. Our system captures the full context: **Task Title**: Send Q4 budget proposal to ACME Corp **Description**: During the October 15 planning meeting, John committed to sending the revised Q4 budget proposal to ACME Corp's CFO. **Meeting Context**: - Quoted from recording at 23:45: "John, can you send the updated proposal with the new pricing structure to their CFO? They need it for their board meeting." - AI Rationale: Identified as actionable due to specific assignee (John), clear deliverable (proposal), explicit deadline (Friday), and confirmation response ("Sure, I'll get that over by Thursday"). **Deadline**: October 18, 2024 at 5:00 PM **Assignee**: John Smith **Creator**: Sarah Johnson Every extracted task includes the actual quote from the meeting and our AI's reasoning for why it identified this as an actionable item. You can always trace back to the source. ### The conversation thread challenge Here's where it gets interesting. Conversations aren't linear. Someone proposes an idea at minute 5. It gets discussed again at minute 15 with modifications. By minute 30, the team decides to do something completely different. Traditional extraction would create three conflicting tasks. Our AI tracks these conversation threads throughout the meeting. It understands when an action item evolves, gets canceled, or morphs into something new. Using advanced dialogue understanding techniques, the system maintains context across the entire conversation - just like a human note-taker would. We use advanced dialogue tracking systems to ensure you get the final, agreed-upon version of each task, not every iteration discussed along the way. ## The Draft state - your safety net AI isn't perfect. That's why we're introducing a new task state: Draft. [Diagram removed for brevity] **What to notice**: - Draft tasks appear in a special review interface before becoming "real" tasks - All tasks from one meeting are bundled into a single process for easy review - Each draft task can be edited, converted, or deleted independently Draft tasks work like a moderation queue. After your meeting, all extracted tasks appear in Draft state, grouped together as one process (using our [launch process without template](mdc:products/pro/integrations/open-api/code-samples/processes/launch-process-without-template) API capability). You'll see all proposed tasks from that meeting in one place. Review them. Edit assignments if needed. Adjust deadlines. Delete tasks that aren't actually actionable. Convert the good ones to Open tasks with a single click. This human-in-the-loop approach solves the accuracy problem. The AI does the heavy lifting of extraction and organization. You provide the final quality check. Together, you get accurate task tracking in minutes instead of hours. ## Technical challenges we're solving ### Accuracy at scale Current state-of-the-art systems face several hurdles: - **Background noise and cross-talk** reduces transcription accuracy - **Technical jargon and industry terms** cause misinterpretation - **Multiple speakers talking simultaneously** creates attribution errors - **Long meetings** exceed AI context windows, losing thread coherence We're implementing solutions including adaptive noise filtering, custom vocabulary training for your industry, speaker diarization, and sliding window analysis that maintains context across long meetings. ### The hallucination problem Large language models sometimes generate tasks that were never discussed - tasks the AI invented based on context clues rather than explicit discussion. Our approach uses multiple validation layers. First, we require explicit evidence from the transcript. Every task must link to specific quoted text. Second, we use confidence scoring. Tasks with low confidence appear with warning flags in the Draft state. Third, the human review step catches any remaining hallucinations before tasks go live. ### Meeting evolution patterns Academic research on meeting analysis reveals common patterns. Understanding these helps our AI extract better tasks: - **Progressive refinement**: Ideas evolve through discussion before becoming tasks - **Implicit delegation**: "Someone should..." becomes "John will..." over time - **Conditional commitments**: "If X happens, then I'll do Y" requires tracking conditions - **Retroactive cancellation**: "Actually, let's not do that" negates earlier commitments Our system recognizes these patterns and adjusts extraction accordingly. ## Platform roadmap We're planning support for all major meeting platforms: ### Phase 1 - Video conferencing giants - **Zoom** - 300+ million daily participants - **Microsoft Teams** - 280 million monthly users - **Google Meet** - 100+ million daily users - **Cisco Webex** - 600 million monthly participants ### Phase 2 - Specialized platforms - **Slack Huddles** - Quick team syncs - **Discord** - Community meetings - **GoToMeeting** - Enterprise focus - **BlueJeans** - Healthcare and finance ### Phase 3 - Recording tools - **Otter.ai** - Meeting transcription specialist - **Fireflies.ai** - AI meeting assistant - **Sembly AI** - Multi-language support - **Jamie** - Bot-free recording ### Phase 4 - Async collaboration - **Loom** - Video messages - **Vidyard** - Sales conversations - **BombBomb** - Video email - **Soapbox** - Internal communications Each integration will support automatic recording upload, real-time transcription where available, and full Draft task workflow. ## Current workaround - build it yourself Can't wait for our official feature? You can build your own meeting-to-tasks pipeline today using Tallyfy's API. Fair warning - this requires technical expertise and ongoing maintenance. ### What you'll need to build You're responsible for: - Capturing and storing meeting recordings - Transcribing audio to text (using services like OpenAI Whisper or Google Speech-to-Text) - Extracting action items from transcripts (using GPT-4 or Claude) - Mapping speakers to Tallyfy users - Creating tasks via our API - Handling errors and retries Tallyfy provides the API to create and track tasks. Everything else is on you. ### High-level architecture ### Extraction patterns that work Through testing, these heuristics improve extraction accuracy: **Explicit action patterns**: - "[Name] will/to [action] by [date]" - "Action item: [description]" - "Next steps: [list]" - "@[name] please [action]" **Temporal markers**: - "by end of day" → today at 5 PM - "next Friday" → calculate from meeting date - "ASAP" → 2 business days default - "before the board meeting" → check calendar API **Assignment indicators**: - Direct: "John, can you..." - Confirmation: "I'll handle..." - Delegation: "Let's have Sarah..." - Volunteering: "I can take that" ### Handling edge cases Your extraction logic needs to handle: ```python # Multiple assignees if "and" in assignee_text or "," in assignee_text: assignees = parse_multiple_assignees(assignee_text) create_task_for_each(assignees) # Conditional tasks if "if" in task_text or "assuming" in task_text: task.add_note("Conditional: " + extract_condition(task_text)) # Rejected tasks if check_for_cancellation(transcript, task_timestamp): skip_task(task) # Don't create if later rejected # Vague deadlines deadline = parse_deadline(deadline_text) if not deadline: deadline = meeting_date + timedelta(days=7) # Default 1 week ``` ### Production considerations **Rate limiting**: Implement exponential backoff for API calls ```javascript async function retryWithBackoff(fn, maxRetries = 3) { for (let i = 0; i < maxRetries; i++) { try { return await fn(); } catch (error) { if (error.status === 429) { await sleep(Math.pow(2, i) * 1000); // 1s, 2s, 4s } else { throw error; } } } } ``` **Idempotency**: Prevent duplicate task creation ```python def generate_task_fingerprint(task): # Create unique ID from meeting + content content = f"{meeting_id}:{task['assignee']}:{task['description']}" return hashlib.md5(content.encode()).hexdigest() # Check before creating if not task_exists(fingerprint): create_task(task) ``` **Privacy and compliance**: - Store recordings in compliant storage (HIPAA/GDPR) - Redact sensitive information from transcripts - Implement access controls on task creation - Maintain audit logs linking tasks to source recordings ### Testing your pipeline Create test cases for common scenarios: ```python test_cases = [ { "transcript": "John, please send the proposal by Friday", "expected": { "assignee": "John", "task": "Send the proposal", "deadline": "Friday" } }, { "transcript": "Someone should update the dashboard. Sarah: I'll do it tomorrow", "expected": { "assignee": "Sarah", "task": "Update the dashboard", "deadline": "tomorrow" } }, { "transcript": "Let's review the budget next week. Actually, cancel that.", "expected": None # Should not create task } ] ``` ### Success metrics Track these metrics to measure your pipeline's effectiveness: - **Extraction accuracy**: Percentage of real action items captured - **False positive rate**: Tasks created that weren't real action items - **Assignment accuracy**: Correctly identified task owners - **Deadline accuracy**: Properly parsed due dates - **Processing time**: Meeting end to tasks created - **User adoption**: Percentage of meetings processed Monitor extraction accuracy and false positive rates before rolling out broadly. ## What's next While you wait for our official feature, the workaround above gets you started. Yes, it requires significant development effort. But teams processing 10+ meetings weekly often find the investment worthwhile. When our official feature launches, you'll get: - Zero-configuration setup - High-quality transcription - Smart conversation thread tracking - The Draft state review workflow - Native integration with all major platforms - Automatic user mapping via SSO - No maintenance or coding required The initial release will support Zoom, Teams, and Google Meet. Additional platforms will follow in subsequent phases. Want early access? Contact our support team to join the beta program. We're especially interested in teams that run 20+ meetings weekly and can provide detailed feedback. Remember - every meeting generates work. Soon, Tallyfy will ensure none of that work gets lost. - **[Handling idempotency](https://tallyfy.com/products/pro/integrations/handling-idempotency-in-webhooks-and-api/)**: Idempotency ensures integrations handle duplicate events gracefully by preventing the same action from being processed multiple times even when webhooks fire repeatedly or external systems send duplicate requests. ## What is idempotency and why it matters Idempotency ensures your integrations work correctly when the same thing happens twice. Think of it like pressing an elevator button - no matter how many times you press it, the elevator only comes once. That's what you want when building integrations with Tallyfy's [webhooks](/products/pro/integrations/webhooks/) and [API](/products/pro/integrations/open-api/). Here's the reality: webhooks can fire multiple times for the same event. External systems might send duplicate API requests. Network glitches happen. Without proper idempotency handling, you'll face a mess - duplicate records in your database, customers getting charged twice, or inventory counts going haywire. ## Common scenarios requiring idempotency ### Webhooks firing multiple times Let's say someone completes a [task](/products/pro/tracking-and-tasks/tasks/) in Tallyfy. Your webhook gets the "task completed" event - great! But what if they reopen that task and complete it again? You'll get another webhook for the exact same task. It happens more than you'd think: 1. User completes the task 2. Your webhook receives the event 3. User realizes they forgot something, reopens the task 4. User completes it again 5. Your webhook receives another event - same task, different timestamp Without idempotency handling, you're looking at chaos: - Duplicate records cluttering your database - Customers getting three confirmation emails for one action - Payment systems processing the same order twice (yikes!) - Inventory numbers that don't match reality ### Process-level webhooks generating multiple events Set up a webhook at the [process](/products/pro/tracking-and-tasks/processes/) level, and you're in for a surprise - it fires for every single task completion in that process. Got 10 tasks? That's 10 webhook events coming your way. The math gets scary fast: - 10-task process = 10 webhook events minimum - Tasks get reopened and recompleted? More events pile up - Your system better be ready for the flood ### External systems sending duplicate events It's not just Tallyfy that can send duplicates - your own systems can too. We've seen it all: - Helpdesk software hiccups and sends the same ticket update twice - Network timeout triggers an automatic retry, but the first request actually went through - Someone double-clicks a button (we've all been there) and fires off multiple API calls ## Implementing idempotency strategies ### Use unique identifiers Tallyfy gives you everything you need to catch duplicates - unique IDs in every webhook payload. Use them! ```json { "event": "task.completed", "task_id": "abc123", "process_id": "xyz789", "completed_at": "2024-01-15T10:30:00Z", "completed_by": "user@example.com" } ``` **Your game plan:** 1. Store the `task_id` and `completed_at` combo in your database 2. Check this combination before processing any webhook 3. Already seen it? Skip or update the existing record 4. Brand new? Process away ### Implement event deduplication You need a dedicated place to track what you've already processed. A simple table works wonders: ```sql CREATE TABLE processed_events ( event_id VARCHAR(255) PRIMARY KEY, event_type VARCHAR(100), processed_at TIMESTAMP, payload JSON ); ``` Each time a webhook arrives: 1. Build a unique event ID: `task_id + event_type + timestamp` 2. Check your table - have you seen this ID before? 3. New event? Process it and save that ID 4. Old news? Log it and move on ### Design for graceful failure Here's where things get interesting. When duplicate API requests come in, don't fight them - work with them: 1. **Return success for duplicate requests**: External system tries to create the same record twice? Don't throw an error. Send back a 200 OK with the existing record. Everyone's happy. 2. **Use conditional updates**: Before updating [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) through the API, check what's already there: - Value already matches? Skip the update - Different value? Go ahead and update - Always add a comment for the audit trail 3. **Use request IDs**: Make external systems include a unique ID with each call: ``` X-Request-ID: unique-request-identifier-123 ``` Keep these IDs for 24 hours. When you see a repeat, you'll know it's a retry. ## Best practices for specific integrations ### Handling task completion webhooks Tasks get reopened and recompleted all the time. You've got to track the full history: 1. Keep a record of every completion: ```json { "task_id": "abc123", "completions": [ {"completed_at": "2024-01-15T10:30:00Z", "completed_by": "user1@example.com"}, {"completed_at": "2024-01-15T14:45:00Z", "completed_by": "user2@example.com"} ] } ``` 2. Pick your strategy based on what makes sense: - Care only about the first completion? Ignore the rest - Need to track every completion? Store them all separately - Only the latest matters? Update your records each time ### Managing process-level webhook volume Got a process with 50 tasks? That's 50 webhooks headed your way. Here's how to handle the deluge: 1. **Batch processing**: Don't process events one by one. Collect them and process in chunks every 5 minutes 2. **Use queues**: Message queues are your friend - they'll prevent your system from choking on the volume 3. **Filter smartly**: Not all tasks are equal. Check the payload and process only what matters to you ### Preventing duplicate API submissions Stop duplicates before they start when external systems talk to Tallyfy: 1. **Use idempotency keys**: Every operation needs its own unique key: ``` POST /api/processes/launch X-Idempotency-Key: ticket-12345-launch-attempt-1 ``` 2. **Check before you leap**: Always verify the current state first: - About to launch a process? Check if it already exists - Completing a task? Make sure it's not already done - Updating a form field? Confirm it needs changing ## Example implementation patterns ### Pattern 1: Webhook processor with deduplication ```javascript async function processWebhook(payload) { // Generate unique event key const eventKey = `${payload.task_id}-${payload.event}-${payload.timestamp}`; // Check if already processed const existing = await db.query('SELECT * FROM processed_events WHERE event_key = ?', [eventKey]); if (existing.length > 0) { console.log('Duplicate event detected, skipping:', eventKey); return { status: 'duplicate', message: 'Event already processed' }; } // Process the event await handleEvent(payload); // Mark as processed await db.query('INSERT INTO processed_events (event_key, processed_at) VALUES (?, NOW())', [eventKey]); return { status: 'processed', message: 'Event processed successfully' }; } ``` ### Pattern 2: API integration with retry safety ```javascript async function updateTaskField(taskId, fieldName, fieldValue, requestId) { // Check if this request was already processed const cachedResult = await cache.get(`request:${requestId}`); if (cachedResult) { return cachedResult; } // Get current task state const task = await tallyfyApi.getTask(taskId); // Check if update is needed if (task.fields[fieldName] === fieldValue) { const result = { status: 'unchanged', message: 'Field already has the desired value' }; await cache.set(`request:${requestId}`, result, 86400); // Cache for 24 hours return result; } // Perform update const updatedTask = await tallyfyApi.updateTask(taskId, { fields: { [fieldName]: fieldValue } }); // Add comment for audit trail await tallyfyApi.addComment(taskId, `Field "${fieldName}" updated to "${fieldValue}" via API integration` ); const result = { status: 'updated', task: updatedTask }; await cache.set(`request:${requestId}`, result, 86400); return result; } ``` ## Testing your idempotency implementation Don't wait for production to find out if your deduplication works. Test it now: 1. **Simulate duplicate webhooks**: Fire the same webhook at your system 3-4 times in a row 2. **Test network retries**: Use tools like Postman to simulate connection timeouts and automatic retries 3. **Check data consistency**: After your tests, verify your data isn't corrupted or duplicated 4. **Monitor production logs**: Watch for duplicate patterns - they'll show up eventually ## Troubleshooting common issues | Issue | Cause | Solution | |-------|-------|----------| | Duplicate records in database | Not checking for existing records before insert | Implement unique constraints and check before insert | | Missing webhook events | Treating duplicates as errors | Log duplicates but don't fail the webhook response | | Inconsistent data state | Processing events out of order | Use timestamps to ensure correct ordering | | API rate limits from retries | Not caching successful responses | Implement response caching with appropriate TTL | :::warning[Important consideration] Always respond with a 2xx status code to webhook requests, even for duplicates. If you return an error, Tallyfy thinks something went wrong and retries - creating even more duplicates. Don't make things worse! ::: ## Next steps You've built idempotency into your integration - now keep it running smoothly: 1. Monitor your logs for duplicate patterns (they'll reveal retry behaviors you didn't expect) 2. Fine-tune your deduplication window based on real-world data 3. Need complete audit trails? Consider event sourcing for the full picture 4. Stay current with Tallyfy's [webhook documentation](/products/pro/integrations/webhooks/) - payload formats can evolve - **[Azure translation services](https://tallyfy.com/products/pro/integrations/azure-translation/)**: Tallyfy offers UI language switching for menus and buttons plus Microsoft Azure AI-powered content translation that automatically translates user-generated text like task descriptions and comments in real-time after administrators connect their Azure API credentials. ## Translation Options in Tallyfy Working with a global team? You've got two ways to handle language barriers in Tallyfy: 1. **UI Language**: Switch the language of menus, buttons, and system messages 2. **Content Translation**: Let Microsoft Azure AI translate what people actually write - task descriptions, comments, everything Here's the thing - if you're operating internationally, you need to know about [global workplace language requirements](/products/pro/integrations/azure-translation/global-workplace-language-requirements/). Many countries actually require translating employee documentation (think SOPs, policies, training materials) into local languages. ### Changing the UI Language Want Tallyfy in your preferred language? This setting changes what *you* see in the interface. - **What it changes**: Menus, buttons, system messages - the works - **How to change it**: 1. Click **Settings** (check the bottom left) 2. Go to **My Account** 3. Find the **Personalization** section and pick your language from the dropdown 4. Boom - Tallyfy updates instantly *Can't find your language? Contact Tallyfy support.* ### Translating Content with Azure AI This is where it gets interesting. Microsoft Azure's translation service can automatically translate everything users type *within* Tallyfy. - **What it translates**: Process descriptions, task instructions, form answers, comments - pretty much all user-generated content - **How it works**: You'll need an API key from Microsoft Azure AI Services (yes, there's some setup involved) - **Who sets it up**: Your Tallyfy Admin connects Tallyfy to your company's Azure account ## Setting up the Azure Translation connection (Admin task) ### What you need - A Microsoft Azure account with Azure AI Services enabled - Your API key and endpoint from the Azure Translation service - Administrator permissions in Tallyfy ### How administrators connect *(The [Azure setup guide](/products/pro/integrations/azure-translation/how-to-set-up-azure-cognitive-ai-integration/) has all the details, but here's what you're looking at)*: 1. Grab your API key and endpoint from Azure 2. Head to **Settings** > **Integrations** in Tallyfy 3. Look for **Azure Translation Services** 4. Plug in your Azure API key and details 5. Hit save Done. You'll see a language selector appear at the top of Tallyfy for everyone. ## Using content translation for all users Once Azure's hooked up, it's simple: 1. Click the language selector icon in the top menu bar (usually looks like a globe or flag) 2. Pick your language 3. Navigate around Tallyfy - all user-written text automatically appears in your chosen language 4. Translations happen in real-time as you click through tasks and processes ## Tips for Better Translations - **Write clearly**: Short, simple sentences translate way better than complex ones - **Review important text**: Got critical information? Have a native speaker double-check those automatic translations - **Watch the jargon**: Your company's specific terms might come out weird in translation - **Stay consistent**: Use the same terms throughout - it helps the AI keep translations consistent too ## Troubleshooting Translation Issues Nothing happening? Here's what to check: 1. Is your Azure API key correct in Tallyfy settings? Double-check it's still active in Azure 2. Did you actually select a language from the translation menu at the top? 3. Make sure Translation service is turned on in your Azure AI Services resource 4. Still stuck? Time to contact Tallyfy support - **[Authentication and SSO](https://tallyfy.com/products/pro/integrations/authentication/)**: Tallyfy offers free Single Sign-On integration for paid plans connecting to corporate identity systems like Microsoft Entra ID Google Workspace Okta and OneLogin with SSO-only enforcement options that can replace traditional e-signatures for internal approvals while providing enhanced security user experience and centralized access control through automated account provisioning and unified authentication policies. ## Single Sign-On integration Tallyfy provides free Single Sign-On (SSO) integration for all customers on paid plans. Connect to your existing corporate identity systems in about 30 minutes. Your team members use their company credentials from Microsoft Entra ID (formerly Azure AD), Google Workspace, Okta, OneLogin, JumpCloud, or other enterprise identity providers to access Tallyfy. Paid plans include optional SSO-only enforcement settings that require everyone to authenticate exclusively through your designated identity provider. ### SSO benefits | Strategic Benefit | Description | |------------------------|------------------------------------------------------------------------| | **Security** | Use your organization's existing security policies and multi-factor authentication for Tallyfy access | | **User Experience** | Users log in with their corporate username and password | | **Access Control** | Manage all Tallyfy access permissions from your identity management system | | **Account Provisioning** | New users automatically get Tallyfy accounts on first SSO login | | **Security Policies** | Enforce the same authentication rules (password complexity, session timeouts) across all systems | | **IT Support** | Eliminate password reset tickets and simplify user account management | ### SSO as replacement for e-signatures SSO authentication creates legally defensible audit trails that can replace traditional e-signature solutions for internal company approvals. **Traditional e-signature challenges**: - Additional cost per signature/user - Separate system to manage and train - Workflow interruption (leave Tallyfy, sign document, return) - Limited integration with process tracking **SSO-based approval advantages**: - **No additional cost**: Included with all paid Tallyfy plans - **Identity verification**: Corporate SSO confirms the approver's identity through company authentication - **Audit trail**: Every approval logged with timestamp, user identity, and IP address - **Workflow integration**: Approvers complete their task without switching tools - **Legal compliance**: SSO authentication meets requirements for internal corporate approvals in most jurisdictions **Common use cases for SSO-based approvals**: - Purchase order approvals - Internal policy acknowledgments - Budget authorizations - Project sign-offs - Compliance confirmations - HR document approvals :::tip[Best practice for approval workflows] Create a dedicated "Approval" task type in your templates with: 1. Approval criteria in the task description 2. Required Yes/No form field for the approval decision 3. Required text field for approval comments/conditions 4. Automatic email notification upon completion This creates a timestamped, authenticated approval record without external e-signature tools. ::: :::note[When you still need traditional e-signatures] For external party signatures (customers, vendors) or specific regulatory requirements (some healthcare/financial documents), you may still need dedicated e-signature tools. Tallyfy integrates with DocuSign and similar platforms for these scenarios. ::: ### Enforcing SSO-only access Organizations can require all users to authenticate through corporate SSO. Tallyfy can lock down access so SSO becomes the only authentication method. #### SSO-only mode effects * **Standard authentication disabled**: Email and password logins disabled organization-wide * **Identity provider provisioning**: All users must come through your corporate identity provider For technical details and security implications, see [Compliance documentation on Mandatory Single Sign-On](/products/pro/compliance/#mandatory-single-sign-on-sso). To enable "SSO only" mode, [contact Tallyfy support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/). ### SSO authentication flow SSO login process: 1. **Organizational portal**: Users access a customized Tallyfy login link for your organization 2. **Identity provider redirect**: Tallyfy redirects to your company's login portal (Microsoft Entra ID, Google Workspace, etc.) 3. **Corporate authentication**: Users enter work credentials and complete multi-factor authentication 4. **Return to Tallyfy**: After authentication, users are automatically logged into Tallyfy 5. **Account provisioning**: First-time users get accounts created automatically using identity provider data ![](https://screenshots.tallyfy.com/tallyfy-sso-flow.png) ### Supported identity providers Tallyfy supports these enterprise identity management systems: #### Microsoft Entra ID (formerly Azure Active Directory) Microsoft's enterprise cloud identity and access management platform. Includes conditional access and multi-factor authentication. [**Azure AD Setup Guide →**](/products/pro/integrations/authentication/how-to-integrate-azure-ad-samlsso-with-tallyfy/) #### Google Workspace (formerly G Suite) Google's identity and productivity platform for businesses using Gmail, Drive, and other Google tools. [**Google Workspace Setup Guide →**](/products/pro/integrations/authentication/how-to-integrate-google-suite-samlsso-with-tallyfy/) #### Okta Cloud-based identity service specializing in enterprise SSO. [**Okta Setup Guide →**](/products/pro/integrations/authentication/how-to-integrate-okta-samlsso-with-tallyfy/) #### OneLogin Identity and access management platform with SSO capabilities. [**OneLogin Setup Guide →**](/products/pro/integrations/authentication/how-to-integrate-onelogin-samlsso-with-tallyfy/) #### JumpCloud Cloud directory platform providing unified device and identity management with SAML-based SSO. [**JumpCloud Setup Guide →**](/products/pro/integrations/authentication/how-to-integrate-jumpcloud-samlsso-with-tallyfy/) #### Other SAML 2.0 Compatible Systems Any identity provider supporting SAML 2.0 can be configured. Contact support to verify compatibility. ### Requirements for SSO setup - **Administrative access**: Admin rights in both Tallyfy and your identity provider - **Configuration exchange**: URLs, security certificates, and metadata exchange between systems - **Attribute mapping**: Configuration for user info (email, name, role) flow from identity provider to Tallyfy - **Testing**: Test with different user types before company-wide rollout :::note[Advanced SSO Integration with AI Tools] For organizations implementing AI workflows with [Model Context Protocol (MCP) servers](/products/pro/integrations/mcp-server/), advanced SSO patterns enable smooth authentication across AI applications. Learn about [enterprise SSO integration with MCP servers](/products/pro/integrations/mcp-server/sso-authentication/) for unified identity management across AI-powered workflow tools. ::: ### Getting started with SSO 1. **Select provider**: Choose the setup guide for your identity system (Microsoft Entra ID, Google, Okta, or OneLogin) 2. **Contact support**: Reach out to Tallyfy support or your account manager 3. **Configure identity provider**: IT team handles technical configuration 4. **Test authentication**: Test with users from different departments and roles 5. **Deploy**: Notify your team about the new login process ### Troubleshooting authentication issues #### Authentication loops during login Users sometimes experience authentication loops where credentials are requested repeatedly or they can't progress past the login screen. This commonly occurs when browser sessions become corrupted or when switching between SSO and regular authentication methods. **Immediate solution**: Force a complete logout by visiting [https://account.tallyfy.com/logout](https://account.tallyfy.com/logout). This URL completely clears all authentication sessions and resolves most login issues. After using this logout URL, clear your browser's cookies for tallyfy.com, wait 10-15 seconds, and try logging in again. For detailed troubleshooting steps, see the [complete authentication loop resolution guide](/products/pro/miscellaneous/troubleshooting/#how-do-i-fix-authentication-loops-when-logging-in). #### Common SSO issues and solutions | Issue | Solution | |-------|----------| | **Login loops with SSO** | Use [https://account.tallyfy.com/logout](https://account.tallyfy.com/logout) to clear sessions, then re-authenticate | | **Can't switch between organizations** | Force logout and clear browser cookies for all tallyfy.com domains | | **SSO and password login conflict** | Clear all sessions using the logout URL before switching authentication methods | | **"Need admin approval" message** | IT administrator must approve Tallyfy in your identity provider settings | - **[Business systems integrations](https://tallyfy.com/products/pro/integrations/business-systems/)**: Tallyfy bridges the execution gap in business operating systems by transforming documented processes into trackable workflows that provide real-time visibility and accountability while supporting frameworks like EOS Scaling Up Lean Six Sigma and Agile methodologies. ## Tallyfy and business operating systems Here's the reality - business operating systems give you the strategic framework, but they're missing something. They don't tell you how to actually execute processes day-to-day. Tallyfy fills that gap. It takes your documented processes and turns them into trackable workflows that work with whatever business methodology you're already using. ### What types of business systems does Tallyfy support? You're probably using one of these already. Tallyfy works with all the major business operating systems and frameworks - it handles the execution piece that these frameworks usually gloss over: **Operating System Frameworks** - EOS® (Entrepreneurial Operating System®) - Complete process component support - Scaling Up - Execution system for documented processes - Traction - Operational accountability and tracking **Management Methodologies** - Lean management - Continuous improvement through process optimization - Six Sigma - Data-driven process improvement and standardization - Agile frameworks - Systematic workflow execution for non-software processes ### Why do business systems need process execution platforms? Business operating systems are great at the big picture stuff - strategic planning, goal setting, vision casting. But when Monday morning rolls around? That's where they fall short. Here's what happens: **Strategic vs. Tactical Gap** - Business systems define *what* needs to happen - Tallyfy ensures *how* it happens consistently - Integration creates complete operational alignment **The CRM Stage Problem** Your CRM shows deals moving through stages, but what about the 20+ micro-tasks between each stage? Who's verifying technical requirements before proposals? Who's getting legal approval before contracts? These critical tasks fall through the cracks because CRMs only track the big milestones, not the actual work that makes those milestones possible. Tallyfy fills this execution gap - every micro-task gets assigned, tracked, and completed in the right sequence. **Documentation vs. Execution** - Frameworks love documentation. You've got binders full of processes. - But who's actually following them? Nobody knows. - Tallyfy turns those dusty documents into workflows people actually use **Accountability and Visibility** - Business systems talk about accountability constantly - But can you see who's doing what right now? Usually not. - Live tracking means no more "I think we're on track" - you'll know exactly where things stand ### Enhancing business system implementations #### Process Component Activation Those processes sitting in your documentation? They become real workflows. Automatic routing sends tasks to the right people. Deadlines keep everything moving. Progress tracking shows you what's actually happening. #### Real-Time Operational Visibility Your leadership meetings just got a lot more productive. Instead of asking "where are we on this?" you're looking at live data. Real numbers replace guesswork. #### Continuous Improvement Integration You finally get the data you need to improve. Which processes take too long? Where do things get stuck? The analytics show you exactly what to fix - and whether your fixes actually worked. #### Scaling and Consistency Add 10 people or 100. Open a new location. The processes stay the same. No more tribal knowledge, no more "that's not how we do it at the other office." ### What implementation approach works best? #### Start with Core Processes Don't try to boil the ocean. Pick 2-3 processes that directly hit your scorecard metrics. Get those humming first. #### Align with Existing Meetings You've already got weekly meetings, quarterly planning sessions. Perfect. Just add process execution data to your existing reports. No extra meetings needed. #### Connect to Strategic Goals Every process improvement should tie back to your rocks, priorities, or whatever your business system calls them. If it doesn't move the needle on your goals, why do it? #### Scale Systematically Once your team sees those first few processes working smoothly, they'll want more. That's when you expand - when people are pulling for it, not when you're pushing. Want the truth? Most business systems fail because they can't bridge the gap between strategy and execution. Tallyfy makes your business system actually work in the real world - where processes need to run every single day, not just during planning sessions. - **[Computer AI agents](https://tallyfy.com/products/pro/integrations/computer-ai-agents/)**: Computer AI Agents are software programs that can see interpret and interact with any screen interface using visual perception and natural language instructions to automate browser-based tasks while Tallyfy provides workflow orchestration structure and transparency around these AI-powered automation capabilities. :::note[Information Currency] Computer AI agent technology is rapidly evolving. This article describes capabilities and vendors as understood at time of writing. Check vendor documentation for current features and availability. ::: ## Understanding computer AI agents Computer AI Agents are software programs that can see what's on your screen, understand it, and take action. Unlike traditional automation that requires specific API connections, these agents navigate web browsers, fill forms, and extract data from any interface by seeing and interpreting visual elements. Think of them as automation that works like a human would - clicking buttons, typing text, reading what's displayed - but without needing custom code for every application. For conversational AI that works with text and documents rather than screens, see our [BYO AI integration](/products/pro/integrations/byo-ai/) that connects ChatGPT, Claude, or Copilot subscriptions. ### How workflow orchestration works with AI agents Tallyfy can provide structure around AI agent execution. The workflow management system provides step-by-step instructions and defines inputs and outputs, while the AI agent handles the screen-based tasks. This separation gives you transparency into what the agent is doing and a framework for managing these automated steps as part of broader business processes. ### Core capabilities of computer AI agents These agents combine large language models with computer vision to interact with applications through their user interface: - **Visual Perception:** Can identify and interpret text, buttons, forms, and other UI elements on screen - **Natural Language Instructions:** Accept goals in plain English rather than requiring scripted code - **Mouse and Keyboard Control:** Execute clicks, typing, scrolling, and navigation actions - **UI Adaptation:** Can often handle interface changes that would break traditional RPA scripts :::warning[Start with simple tasks] AI agents work best with straightforward, repetitive tasks like filling specific form fields with known values. Complex, goal-driven work requiring significant decision-making can produce inconsistent results and high costs. Start small and expand gradually based on results. ::: ### Integration pattern with workflow management [Diagram removed for brevity] **What to notice:** - Workflow system provides structured inputs (instructions, data, criteria) that guide the AI agent - Agent loops through perceive-understand-execute cycles until task completion - Outputs can be captured back for tracking and further processing **How this pattern works:** 1. **Define the process:** Document your business process, identifying which steps humans perform and which could be handled by AI agents 2. **Assign agent tasks:** Steps involving web navigation, data extraction, or form filling can be assigned to AI agents 3. **Provide instructions:** The workflow system sends instructions and any needed data from previous steps 4. **Monitor execution:** Agent actions are logged for transparency and troubleshooting 5. **Capture outputs:** Results return to the workflow system for next steps 6. **Refine over time:** Adjust instructions based on results to improve reliability ### Potential benefits and considerations When successfully implemented, computer AI agents may provide: - **Broader automation scope:** Can work with applications that lack APIs or integration options - **Reduced manual effort:** Handles repetitive screen-based tasks that previously required human attention - **UI resilience:** Some ability to adapt when interfaces change, though not guaranteed - **Process visibility:** When orchestrated through workflow management, actions can be logged and tracked **Important limitations to understand:** - **Reliability varies:** Success rates depend on task complexity, website structure, and vendor capabilities - **Costs can scale quickly:** Many vendors charge per task or execution time - **Not deterministic:** Unlike traditional code, agents may behave inconsistently - **Still emerging:** Vendor capabilities, pricing, and availability continue to evolve The related articles below cover specific vendors and comparisons to help you evaluate if these tools fit your use case. - **[Document management](https://tallyfy.com/products/pro/integrations/document-management/)**: Tallyfy can integrate with existing document management systems to handle workflow orchestration while maintaining your current security protocols and document storage solutions. ## Integrate document management systems with Tallyfy You can seamlessly connect your existing document management system (DMS) to Tallyfy workflows. This approach lets you maintain your current security protocols and document storage while using Tallyfy to orchestrate the workflow around those documents. Think of it this way - Tallyfy handles the "who does what and when" while your DMS handles the "where documents live and how they're secured." It's the best of both worlds. ## Choosing your document strategy When handling documents in workflows, you've got two paths. Each serves different needs. ### Using your existing DMS **Perfect for:** - Organizations with strict compliance requirements (HIPAA, SOC 2, GDPR) - Legal firms handling privileged documents - Healthcare providers managing patient records - Financial institutions with regulatory constraints - Companies with existing DMS investments **Key advantages:** - Documents stay in your secured, compliant environment - Maintain existing access controls and audit trails - No file size limitations from Tallyfy - Use familiar DMS features (versioning, encryption, retention policies) - Reduced storage costs in Tallyfy **Trade-offs:** - Requires initial setup of file request links - Users interact with two systems - Additional step to generate unique upload links ### Using Tallyfy's built-in file management **Perfect for:** - Simple document workflows without special compliance needs - Teams wanting everything in one place - Quick implementations without IT involvement - Internal processes with trusted users **Key advantages:** - Single system for users to learn - Files attached directly to tasks - Simpler setup - no integration needed - Built-in commenting on files - Automatic file organization by process **Trade-offs:** - 250MB file size limit per upload - Less granular access controls - Storage counts toward Tallyfy limits - Limited retention policy options ## The hybrid approach Many organizations use a hybrid strategy. They handle sensitive documents through their DMS while using Tallyfy's file uploads for routine attachments like screenshots or simple forms. For instance, an HR team might collect employment agreements through secure DMS links but attach interview feedback directly in Tallyfy tasks. ## How file request links work File request links let external users upload documents directly to your DMS without needing accounts. Here's the workflow: 1. Your DMS generates a unique upload link for a specific folder 2. You store this link in a Tallyfy text field 3. The workflow shares this link with the person who needs to upload 4. They click the link and upload directly to your DMS 5. Your team accesses the documents from the DMS The documents never pass through Tallyfy - maintaining your security boundary. ## Security considerations Using your DMS for document collection provides several security benefits: **Data sovereignty** - Documents remain in your controlled environment, important for organizations with data residency requirements. **Compliance maintenance** - Your existing compliance certifications and controls stay intact. **Access control** - DMS permissions determine who sees what, independent of Tallyfy access. **Audit trails** - Document access logs remain in your DMS for compliance reporting. ## Implementation patterns ### Pattern 1: Individual file requests Generate unique upload links for each process instance. Best for collecting sensitive documents from different clients or patients. ### Pattern 2: Shared collection folders Use the same upload link across multiple process runs. Works well for internal document submission where security is less critical. ### Pattern 3: Automated link generation Use your DMS API to automatically generate fresh upload links when launching processes. Requires technical setup but provides the smoothest experience. ## Getting started Start with our guide on [file request links](mdc:products/pro/integrations/document-management/file-request-links/) to understand the concept, then explore vendor-specific implementations for your DMS platform. - **[Email and SMTP](https://tallyfy.com/products/pro/integrations/email/)**: Tallyfy offers five email integration options including custom SMTP for branded domain sending and a Gmail add-on that lets users launch processes and manage tasks directly from their inbox along with customizable notifications and upcoming features for interactive email actions and personal email account connections. ## What email integration options does Tallyfy provide? Tallyfy connects with your email in five powerful ways - custom SMTP, Gmail add-on, automated notifications, interactive actions (coming soon), and personalized email sending (coming soon). You'll reduce context switching and keep everything in one workflow. Here's the thing: your team already lives in email. Why force them somewhere else? These integrations bring Tallyfy's workflow power directly into the inbox they check 20 times a day. ### Custom SMTP configuration Want your workflow emails to come from your own domain? Tallyfy lets you configure custom SMTP servers, which means all notifications come from yourcompany.com instead of Tallyfy's servers. This isn't just about branding. You get total control over email delivery, plus everything stays within your IT team's existing security setup. #### Why implement custom SMTP? - **Professional Branding**: Emails come directly from your company domain, keeping your brand consistent. - **Better Deliverability**: Uses your organization's established email reputation and delivery infrastructure. - **Regulatory Compliance**: Keeps all email communication within your company's controlled systems and compliance frameworks. - **Advanced Filtering**: Uses your organization's existing email rules, security filters, and governance policies. :::caution[Replying to Emails Won't Add Comments] Normally, users can reply to a Tallyfy email notification, and their reply automatically becomes a comment on the task. If you use Custom SMTP, this reply-by-email feature **will not work**. Replies will go to the sender but won't be added as comments in Tallyfy. ::: *(Setting up Custom SMTP requires technical details from your IT team. See the [Custom SMTP Setup Guide](/products/pro/integrations/email/how-to-set-up-custom-smtp-in-tallyfy/) - Note: This guide is technical).* ### What is the Tallyfy Gmail Add-on? The Tallyfy [Gmail add-on](/products/pro/integrations/email/how-can-i-manage-my-tasks-with-tallyfys-gmail-add-on/) transforms your inbox into a workflow command center. No more tab switching. - **Start Processes**: Got an email that needs action? Launch a process from it in 2 clicks. - **Email-to-Task Conversion**: Convert that "Can you handle this?" email into a trackable task with deadlines and assignments. - **Integrated Task Management**: See all your tasks right in Gmail - check them off without leaving your inbox. ### Managing email notifications Too many emails? Not enough? Tallyfy notifies you about task assignments, comments, and process updates - but you control the flow. Each person sets their own notification preferences (daily digest, instant, or off completely). Check [Manage Email Notifications](/products/pro/settings/personal-settings/how-can-i-manage-email-notifications-in-tallyfy/) to customize your settings. ### What are Interactive Email Actions in development? Picture this: you get a Tallyfy notification about an approval task. Instead of clicking through to the app, you just hit "Approve" right in the email. Done. That's what we're building with [interactive email actions](/products/pro/integrations/interactive-email-actions/). Microsoft Outlook calls them Actionable Messages, Gmail calls them Markup Actions - we call them a huge timesaver. You'll approve tasks, add comments, and complete simple actions without ever leaving your email client. We're testing this now and can't wait to release it. ### What is Connect Your Email (coming soon)? We're developing a game-changing feature that will let individual users [connect their personal email accounts](/products/pro/integrations/email/connect-your-email/) (Gmail or Outlook) to send workflow emails directly from their own address. Unlike custom SMTP which uses a centralized system email, this feature creates a one-to-one connection between each user and their email account. When Sarah assigns you a task, you'll see it coming from sarah@yourcompany.com, not from notifications@yourcompany.com. This personal touch can improve email open rates and engagement. - **[Actions within emails](https://tallyfy.com/products/pro/integrations/interactive-email-actions/)**: Tallyfy is exploring interactive email actions that would allow users to complete tasks directly within their email inbox using Microsoft Actionable Messages for Outlook and Gmail Markup Actions for Gmail without switching between applications. ## Take action on tasks directly from email You can't - yet. But we're working on something that could change how you handle tasks in your inbox. Interactive email actions would let you complete Tallyfy tasks right inside your email. No switching apps. No extra clicks. Just get things done where you already spend your time. The technology exists - **Microsoft Actionable Messages** for Outlook and **Gmail Markup Actions** for Gmail - and we're exploring how to bring it to Tallyfy. ### What are interactive email actions in Tallyfy? Think of them as buttons and forms that actually work inside your email. You'd approve a request, mark a task complete, or add a comment - all without clicking a link or opening another tab. Here's the difference: Traditional emails make you click through to a web page. Interactive emails bring the action to you. Buttons, forms, confirmations - they'd all work right there in your inbox. #### Microsoft Actionable Messages Microsoft's solution embeds "Adaptive Cards" into Outlook emails. These cards display information and let you take action: * Click **Approve** or **Reject** on a Tallyfy approval task * Add a quick comment to a task * Mark a simple task as complete When you click something in the card, Outlook sends your action back to Tallyfy to update the task. It's secure. It's fast. Learn more on the [Microsoft Learn platform](https://learn.microsoft.com/en-us/outlook/actionable-messages/). #### Gmail Markup Actions Gmail uses `schema.org` markup (typically JSON-LD) in the email's HTML. This markup tells Gmail to show interactive elements. You get two main types: * **One-Click Actions**: Perfect for approvals and confirmations - one tap and you're done * **Go-To Actions**: For complex stuff that needs a full webpage Just like Outlook, when you click an action, Gmail sends it back to the service. Check out the [Google Developers documentation for Gmail Markup Actions](https://developers.google.com/workspace/gmail/markup/actions/actions-overview) for the technical details. ### How could this benefit Tallyfy users? Let's be honest - switching between email and web apps is annoying. Interactive emails would fix that: * **Speed**: Approve requests in 2 seconds instead of 30. No login screens, no page loads. * **Focus**: Stay in your inbox for quick actions. Your flow stays unbroken. * **Mobile-friendly**: Ever tried logging into a web app on your phone? Yeah, exactly. One-tap actions would be a game-changer. * **Time savings**: Those 5-second approvals add up. If you handle 20 tasks daily, you'd save 10-15 minutes every single day. ### Potential Tallyfy use cases Here's what we're thinking about: * **One-click approvals/rejections**: Get an approval request. Click **Approve** or **Reject**. Done. No login required. * **Marking tasks complete**: Some tasks just need acknowledgment. One button in the email could handle it. * **Adding quick comments**: See a task update? Reply to the email, and your comment gets added to the task automatically. * **Simple form submissions**: Need to pick an option or enter a short response? Do it right in the email (yes, forms can work there too). ### What's next? This isn't live yet - we're still exploring. Building interactive emails isn't simple. We need rock-solid security, and it has to work perfectly across different email clients. That takes time. But we think it's worth it. The productivity gains would be huge. We'll keep you posted as we figure out the best way to make this happen. - **[MCP server](https://tallyfy.com/products/pro/integrations/mcp-server/)**: Tallyfy's MCP Server enables natural language interaction with workflows through AI assistants by providing tools for searching tasks and processes managing users and templates analyzing workflow health and creating automation rules without requiring API knowledge. ## Tallyfy MCP Server (Preview) :::warning[Feature in Development] The Tallyfy MCP Server is currently in development and **subject to change**. The features and capabilities described here represent the current state of development and may evolve before the official release. ::: :::note[MCP Client Compatibility - Industry Standard] MCP has become the industry standard for connecting AI to external tools. In December 2025, Anthropic donated MCP to the Agentic AI Foundation under the Linux Foundation - co-founded by Anthropic, Block, and OpenAI, with AWS, Google, Microsoft, Cloudflare, and Bloomberg as supporting members. You can connect Tallyfy's MCP server with **OpenAI ChatGPT**, **Claude**, **Google Gemini**, **Microsoft Copilot Studio**, and **Slack** - all major AI platforms now support MCP. The text-based UI has limitations (explained below), but we're building our own chat interface that fixes these. Add MCP to your AI subscription today for immediate value. ::: Tallyfy's MCP (Model Context Protocol) Server lets you control your workflows with plain English through any AI platform that supports MCP. You describe what you want. The AI handles the rest - no API endpoints or complex interfaces required. For a simpler approach that uses your existing AI subscriptions without technical setup, see our upcoming [BYO AI (Bring Your Own AI)](/products/pro/integrations/byo-ai/) integration. ### What is MCP? Think of MCP as a universal translator between AI assistants and your business tools. It's an open standard - now governed by the Agentic AI Foundation under the Linux Foundation - that creates secure connections, letting AI models talk to external systems while you stay in control of security and permissions. All major AI providers (OpenAI, Anthropic, Google, Microsoft) support MCP, making it the de facto protocol for connecting AI to real-world data and tools. ### How Tallyfy MCP Server works The Tallyfy MCP Server connects AI assistants (Claude, ChatGPT, Gemini, Copilot, and others) directly to your Tallyfy organization. Give it your API token. That's it. Now you can: - Ask questions about your [processes](/products/pro/tracking-and-tasks/processes/) and [tasks](/products/pro/tracking-and-tasks/tasks/) in natural language - Create and manage tasks through conversation - Analyze [templates](/products/pro/documenting/templates/) and get suggestions for improvements - Search across your organization's workflows - Manage [users](/products/pro/documenting/members/) and [guests](/products/pro/documenting/guests/) **Example interactions:** - "Show me all overdue tasks for John" - "Create a task for reviewing the quarterly budget, due next Friday" - "What templates do we have for customer onboarding?" - "Analyze the health of our 'Employee Onboarding' template" ### Current capabilities (Preview) Here's what the MCP Server can do right now (remember, it's still in preview): ## Search and discovery tools **Search across your organization:** - `search_for_tasks` - Find tasks using natural language queries - `search_for_processes` - Locate specific [processes](/products/pro/tracking-and-tasks/processes/) by description or criteria - `search_for_templates` - Discover [templates](/products/pro/documenting/templates/) that match your needs **Examples:** - "Find all tasks related to budget approval" - "Search for processes containing 'customer onboarding'" - "Show me templates for HR workflows" ## User and access management **Organization members:** - `get_organization_users` - List all [members](/products/pro/documenting/members/) in your organization - `get_organization_users_list` - Get a simplified list of users - `invite_user_to_organization` - Add new [members](/products/pro/documenting/members/) to your Tallyfy organization **Guest management:** - `get_organization_guests` - View all [guests](/products/pro/documenting/guests/) with access to your workflows - `get_organization_guests_list` - Get a simplified guest list **Helper functions:** - `resolve_user_ids` - Convert user names or emails to internal IDs - `resolve_group_ids` - Convert group names to internal identifiers ## Task management and tracking **Personal and team tasks:** - `get_my_tasks` - Retrieve your assigned [tasks](/products/pro/tracking-and-tasks/tasks/) - `get_user_tasks` - View tasks assigned to specific team members - `get_tasks_for_process` - List all tasks within a particular [process](/products/pro/tracking-and-tasks/processes/) **Task creation:** - `create_task_from_text` - Create new tasks using natural language descriptions with automatic due date extraction **Process monitoring:** - `get_organization_runs` - View all running [processes](/products/pro/tracking-and-tasks/processes/) with filtering options ## Template design and optimization **Template analysis:** - `get_template` - Retrieve detailed information about specific [templates](/products/pro/documenting/templates/) - `assess_template_health` - Get thorough analysis of template effectiveness - `get_step_dependencies` - Understand how steps relate to each other - `suggest_step_deadline` - Get AI-powered deadline recommendations **Form field management:** - `add_form_field_to_step` - Add new [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) to template steps - `update_form_field` - Modify existing form field properties - `move_form_field` - Relocate form fields between steps - `delete_form_field` - Remove unnecessary form fields - `suggest_form_fields_for_step` - Get AI suggestions for useful form fields **Dropdown field management:** - `get_dropdown_options` - View available options for dropdown fields - `update_dropdown_options` - Modify dropdown choices **Template structure:** - `add_assignees_to_step` - Assign [members](/products/pro/documenting/members/) or [guests](/products/pro/documenting/guests/) to template steps - `edit_description_on_step` - Update step descriptions and instructions - `add_step_to_template` - Insert new steps into templates ## Automation and workflow logic **Automation rules:** - `create_automation_rule` - Set up new [automations](/products/pro/documenting/templates/automations/) for templates - `update_automation_rule` - Modify existing automation logic - `delete_automation_rule` - Remove automation rules - `analyze_template_automations` - Get insights into current automation setup **Optimization:** - `consolidate_automation_rules` - Simplify complex automation setups - `suggest_automation_consolidation` - Get recommendations for automation improvements - `get_step_visibility_conditions` - Understand when steps appear or hide **Kickoff optimization:** - `suggest_kickoff_fields` - Get recommendations for process launch [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) ## System utilities **Server management:** - `get_server_status` - Check MCP server health and connectivity - `get_available_tools` - List all available MCP tools and their descriptions ### Security and authentication The MCP Server needs your Tallyfy API token to connect. Why? Simple: - Only authorized users can touch your organization's data - Every action respects your existing permissions - Audit trails show exactly who did what - Your data stays protected by Tallyfy's [security](/products/pro/compliance/) protocols ### Getting started (When available) Once the MCP Server is officially released, you'll be able to: 1. **Set up the connection** using your Tallyfy API credentials 2. **Configure your AI assistant** to connect to the Tallyfy MCP Server 3. **Start conversing** with your Tallyfy data using natural language 4. **Perform complex workflows** through simple descriptions ### Available MCP integrations Ready to connect? Pick your AI platform: - **[Claude Desktop (Anthropic)](/products/pro/integrations/mcp-server/claude-anthropic/)** - Native MCP support for all Claude.ai subscription tiers, Desktop Extensions, remote OAuth - **[ChatGPT (OpenAI)](/products/pro/integrations/mcp-server/openai-chatgpt/)** - Full MCP support via Apps (Pro/Plus/Team/Enterprise/Education plans) - **[Google Gemini](/products/pro/integrations/mcp-server/google-gemini/)** - Managed MCP servers, Gemini CLI with FastMCP integration - **[Microsoft Copilot Studio](/products/pro/integrations/mcp-server/microsoft-copilot-studio/)** - Enterprise-grade MCP with Power Platform integration, Agent 365 - **Slack** - Official MCP support with Real-time Search API (Enterprise+ plans) ### Future capabilities Coming soon (we're working on these right now): - Launch and manage processes directly - Advanced reports with charts and insights - Connect to other [middleware](/products/pro/integrations/middleware/) platforms - Build custom automations just by describing them - Real-time team collaboration features ### Technical architecture Under the hood, we've built: - **Core SDK** - Python code that talks to Tallyfy's API - **MCP Server** - The actual protocol implementation - **Tool Framework** - Structured definitions so AI knows what it can do - **Authentication Layer** - Token-based security (your data stays safe) - **Natural Language Processing** - Turns your questions into API calls ## Major limitations of text-based AI interfaces Here's the thing - MCP is powerful, but text-based AI chat has some frustrating limitations when you're trying to use Tallyfy's visual workflow features: ### Visual interface constraints You can't see what you're doing. That's the problem. - **No visual process tracker**: Cannot display Tallyfy's bird's-eye view of running [processes](/products/pro/tracking-and-tasks/processes/) with visual progress indicators - **Missing template builder**: Cannot show the drag-and-drop template interface or visualize step dependencies and branching logic - **Lack of aggregated views**: Cannot present easily filterable views to see processes and tasks at a glance - **No real-time progress**: Cannot show live updates as team members complete tasks or processes advance ### Form field interaction challenges Remember those nice dropdown menus and date pickers in Tallyfy? In text chat, they turn into a mess: - **Dropdown fields**: When a task has dropdown boxes with multiple options, text-based AI must list all options as plain text, making selection tedious - **Multi-select inputs**: Complex form inputs lose their intuitive interface when reduced to text commands - **Date/time pickers**: Visual calendar and time selection tools must be replaced with manual text entry - **File uploads**: Cannot properly handle file upload fields through conversational interface ### Assignment and collaboration barriers Assigning work to your team? It gets clunky fast: - **Assignee selection**: Cannot easily pick assignees as Tallyfy's UI suggests [members](/products/pro/documenting/members/), [guests](/products/pro/documenting/guests/), job titles, and groups with visual indicators - **Bulk operations**: Managing multiple assignments or reassigning many tasks becomes inefficient through individual text commands - **Team collaboration**: Real-time collaborative features like simultaneous template editing are reduced to sequential interactions ### Template creation limitations Want to build a template? Text chat makes it painful: - **Step visualization**: Cannot see all steps in a template at once or understand their relationships - **Reordering steps**: No drag-and-drop capability; must use complex text commands - **Automation configuration**: Complex [automation rules](/products/pro/documenting/templates/automations/) are difficult to set up through conversational interfaces - **Preview functionality**: Cannot visually preview how the template will function before deployment ## Ideal use cases for MCP with text-based AI Don't get us wrong - there are times when text-based MCP absolutely shines. Let's talk about those. ### Natural language search and discovery This is where MCP really works. Ask complex questions, get specific answers: - **Template search**: "Find all templates related to employee onboarding that include background check steps" - **Process discovery**: "Show me all customer onboarding processes that took longer than 5 days to complete" - **Task queries**: "Which tasks are overdue and assigned to the sales team?" - **Cross-reference search**: "Find templates that use the 'Budget Approval' form field" ### Intelligent template generation Got a messy document? AI turns it into clean, structured templates in minutes: - **Auto-creating form fields**: Upload existing forms or documents and let AI automatically generate appropriate [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) with validation rules - **Flowchart conversion**: Study flowcharts or process diagrams to automatically create [templates](/products/pro/documenting/templates/) with proper step sequences - **Automation generation**: Analyze business rules in plain language and convert them to [automation rules](/products/pro/documenting/templates/automations/) - **Bulk field creation**: Generate multiple related form fields based on document analysis ### What-if scenario testing Want to test changes before making them? MCP lets you run simulations: - **Automation testing**: "If I set up an automation to assign tasks based on deal value, show me how it would route these 5 example deals" - **Process optimization**: "What would happen if we removed the approval step for purchases under $1,000?" - **Workload analysis**: "Show me how task distribution would change if we reassigned all of John's templates to Sarah" - **Time estimation**: "Based on historical data, estimate completion time if we add a review step" ### Intelligent process updates Your compliance docs changed? AI spots the differences and updates everything in one go: - **Document-based updates**: "Here's our updated SOX compliance procedure. Update our audit template to match these new requirements" - **Change highlighting**: AI can identify exactly what changed and update only the affected parts - **Version comparison**: Compare old and new process documents to generate precise template modifications - **Bulk updates**: Apply consistent changes across multiple templates based on policy updates ### Pattern recognition and optimization MCP watches how your team actually works - then suggests smart improvements: - **Ad-hoc task analysis**: "Look at one-off tasks added to hiring processes last month and suggest which should be added to the template" - **Bottleneck identification**: "Analyze which steps consistently cause delays and suggest optimizations" - **Template consolidation**: "Find similar templates that could be merged into a single, more flexible template" - **Best practice extraction**: "Identify common patterns in high-performing processes and suggest template improvements" ### Complex reporting with citations Need hard data? AI digs deep and shows you exactly where to look: - **Performance queries**: "Which step in our sales process has the longest average completion time, and which team members are fastest?" - **Compliance reporting**: "Show all instances where required approvals were skipped, with links to specific processes" - **Trend analysis**: "How has our customer onboarding time changed over the last 6 months, and what factors contributed?" - **Cross-functional insights**: "Which departments most frequently add ad-hoc tasks, and what types of tasks are they?" We'll let you know the moment this feature goes live. Setup guides are coming too. - **[Middleware](https://tallyfy.com/products/pro/integrations/middleware/)**: Middleware platforms like Zapier Make and Power Automate enable non-technical users to connect Tallyfy with thousands of business applications through visual drag-and-drop interfaces that eliminate coding requirements while providing features like automatic error handling and data transformation for smooth workflow automation across multiple systems. ## Connect Tallyfy without coding Middleware platforms like Zapier, Make, and Power Automate connect Tallyfy to your other business apps - CRMs, spreadsheets, email tools, you name it. They're visual tools that let you drag and drop connections between systems. No coding required. Here's the thing: these tools put automation power directly in your hands. You don't need to wait for IT or hire developers. Finally, a way to connect systems without begging the dev team for help. This integration-first approach is core to [how we built Tallyfy](/products/pro/miscellaneous/about-tallyfy/) - your data flows freely between all your tools. ### What strategic benefits does Middleware provide when integrated with Tallyfy? | Strategic Benefit | Description | |------------------------|------------------------------------------------------------------| | **Zero Coding Required** | Connect applications without technical API knowledge or development expertise | | **Rapid Implementation** | Set up connections in minutes instead of weeks of custom coding | | **Reduced Maintenance** | Middleware vendors maintain and update all connections automatically | | **Visual Workflow Design** | Create sophisticated integrations using intuitive drag-and-drop interfaces | | **Extensive App Library** | Access thousands of pre-built connections to popular business applications | | **Intelligent Data Transformation** | Convert data between Tallyfy's format and other application requirements | | **Advanced Error Handling** | Built-in automated retry mechanisms and error recovery for failed transfers | | **Enterprise Scalability** | Handle high-volume data transfers and complex multi-system integrations | ### What are common Middleware use cases with Tallyfy for business automation? #### 1. How can I automatically initiate Tallyfy processes from external applications? - Launch processes when events happen in other systems (like when a deal closes in your CRM). - Pre-fill form fields with data from the triggering app - no manual data entry. - Assign tasks based on information from external systems. #### 2. How can I distribute Tallyfy data to external systems automatically? - Push form responses to CRMs, ERPs, or spreadsheets. - Update external systems when processes hit milestones or complete. - Keep customer information synchronized across all your tools in real-time. #### 3. How can I orchestrate multi-application workflows? - Build workflows that span Tallyfy and multiple other applications. - Coordinate processes running across different platforms. - Eliminate manual data entry between systems once and for all. Want to know how this actually works? These platforms turn your disconnected apps into one smooth-running machine. ### What are the most effective Middleware platforms for Tallyfy integration? Tallyfy works with all the major middleware platforms. Here's what you need to know about each: #### Zapier :::note[Choosing a Tool] Zapier works well for simple connections. For more complex workflows or higher data volumes, consider **Make.com** or **Microsoft Power Automate**, which offer different capabilities. For full control, developers can use Tallyfy's [Open API](/products/pro/integrations/open-api/). ::: - **Good for**: Beginners, simple connections. - **Features**: Thousands of app connections, easy visual editor. - **Downsides**: Can be less flexible for complex needs. - [**View Zapier Guide →**](/products/pro/integrations/middleware/zapier/) #### Microsoft Power Automate - **Good for**: Companies using Microsoft 365. - **Features**: Strong connection to Microsoft apps, can automate desktop tasks. - **Downsides**: Interface can be more complex, best within Microsoft ecosystem. - [**View Power Automate Guide →**](/products/pro/integrations/middleware/power-automate/) #### n8n - **Good for**: Organizations wanting open-source flexibility and self-hosting options. - **Features**: Self-hosting option, visual workflows, code flexibility, extensive integrations. - **Downsides**: Requires more technical setup if self-hosting. - [**View n8n Guide →**](/products/pro/integrations/middleware/n8n/) #### Make.com (formerly Integromat) - **Good for**: Users needing more advanced options. - **Features**: Powerful data handling, visual design for complex flows. - **Downsides**: Can be harder to learn initially. #### Workato - **Good for**: Large companies with complex enterprise needs. - **Features**: Strong security, good for managing many integrations, recipe versioning. - **Downsides**: Enterprise-focused, aimed at larger organizations. - [**View Workato Guide →**](/products/pro/integrations/middleware/workato/) #### Tray.io - **Good for**: Building very complex, multi-step workflows. - **Features**: Handles complex logic and branching well. - **Downsides**: More technical to use. ### Implementation steps 1. **Strategic Planning**: Figure out exactly what data needs to move between Tallyfy and your other apps. Which direction? How often? Get specific. 2. **Platform Selection**: Pick the middleware that matches your needs and technical skills. Don't overspend on features you won't use. 3. **Workflow Design**: Map out your integration - what triggers it, how data transforms, where it ends up. 4. **Implementation & Testing**: Build your connections and test everything. Really test it. Break it on purpose to see what happens. 5. **Ongoing Monitoring**: Set up monitoring so you know if something stops working. Trust me, you'll thank yourself later. Follow these steps and you'll have a solid integration that actually works long-term. The following articles provide more details on using specific middleware tools with Tallyfy. - **[Tallyfy Analytics](https://tallyfy.com/products/pro/integrations/analytics/)**: Tallyfy Analytics is an add-on service that copies workflow data to a dedicated Amazon Athena infrastructure where users can connect BI tools like Tableau and Power BI to build custom reports and perform deep analysis on process performance trends and task completion metrics. ## Tallyfy Analytics overview Tallyfy Analytics is an add-on that copies your workflow data to a dedicated analytical infrastructure. You get the full picture - every task, every process, ready for deep analysis. Here's what makes it powerful: you can connect your favorite BI tools like Tableau, Power BI, and Looker directly to your Tallyfy data. Build custom reports that answer questions the standard interface can't. Track trends over months. Spot bottlenecks instantly. ### Key features - **Complete Process Data Access**: Every workflow, every task, every field - it's all there in your analytical database. - **Advanced SQL Query Capabilities**: Write SQL queries to slice your data any way you need. Join tables, aggregate metrics, filter by date ranges. - **Business Intelligence Tool Integration**: Works with any tool that supports Amazon Athena[^1] - that's most enterprise BI platforms. - **Custom Dashboard Creation**: Build exactly the reports your team needs. No more waiting for feature requests. - **Trend Analysis and Performance Tracking**: See how your processes evolve over 3 months, 6 months, or longer. Historical data tells the real story. ### Operational details - **Add-on Service**: It's an add-on feature for Tallyfy customers. - **Additional Service**: This is an add-on service (contact Tallyfy for details - availability varies by data volume). - **Secure Private Infrastructure**: Your data lives in its own private Amazon Athena environment. Nobody else can access it. ### Tracking time spent on tasks While Tallyfy Analytics automatically captures task completion timestamps, getting accurate data about actual working time requires a different approach. See our guide on [how to track time spent on tasks](/products/pro/tutorials/how-to/track-time-in-tasks/) to learn about implementing clean time tracking with form fields - this ensures you capture real effort time, not just elapsed calendar time. :::note[Data Collection Starts After Activation] Tallyfy only starts collecting and processing data for Analytics *after* you have activated the add-on. It does not include data from before activation. ::: :::note[Timestamp handling in Analytics] All timestamps in Tallyfy Analytics data are stored in ISO 8601 format[^2] without timezone information. This ensures consistent, timezone-agnostic data storage for accurate analysis across global teams. In Tallyfy's user interface, these universal timestamps are automatically converted to show in each user's personal timezone setting. ::: ### Security credentials Once we activate Analytics for you, you'll receive two sets of credentials: 1. **AWS Console Administrative Login**: Full access to the AWS web console where you can manage users, set permissions, and monitor usage. 2. **API Access Key & Secret Key Pair**: These connect your BI tools to the data. You'll paste them into Power BI, Tableau, or whatever tool you're using. ### Getting started Ready to dive into your process data? Contact Tallyfy support or your account manager. They'll walk you through the setup process and get everything configured. [^1]: AWS serverless query service for analyzing data using standard SQL without managing infrastructure [^2]: International standard for date/time representation like YYYY-MM-DDTHH:MM:SS, ensuring consistent parsing - **[Robotics](https://tallyfy.com/products/pro/integrations/robotics/)**: This section explores robotics workflow management challenges including communication protocols like OPC UA and ROS integration architecture security requirements human-robot collaboration patterns safety compliance technical readiness organizational considerations and industry applications across manufacturing logistics healthcare and food sectors while addressing protocol complexity network security latency sensitivity and legacy system limitations. ## Understanding robotics workflow challenges This section explores how workflow management applies to physical robotics operations - focusing on the real challenges organizations face when coordinating robot systems with human teams. Industrial and commercial robots operate using proprietary control systems and communication protocols. Connecting these systems to broader business workflows requires middleware, protocol translation, and careful architecture planning. ## Common robotics communication protocols ### OPC UA (Open Platform Communications Unified Architecture) Industrial standard used by major robot manufacturers (ABB, KUKA, FANUC, Siemens). Provides secure, reliable machine-to-machine communication with built-in data modeling and service-oriented architecture. ### ROS/ROS2 (Robot Operating System) Open-source robotics middleware widely used in research and development. ROS2 uses DDS (Data Distribution Service) for real-time communication between nodes. Common in academic settings and newer collaborative robots. ### MQTT (Message Queuing Telemetry Transport) Lightweight publish-subscribe protocol designed for IoT devices. Used for robot telemetry and event-driven communication. Lower bandwidth requirements than OPC UA. ### Proprietary protocols Many robot manufacturers use proprietary communication methods requiring vendor-specific SDKs or edge devices for translation to standard protocols. ## Integration architecture considerations ### Network topology Robot systems typically require network segregation between operational technology (OT) and information technology (IT) networks. Integration points usually occur through: - DMZ (demilitarized zone) with controlled access - Edge computing devices that bridge OT and IT networks - API gateways with rate limiting and authentication - Message queues for asynchronous communication ### Security requirements When connecting robots to external systems: - Network isolation between robot control and business networks - Authentication and authorization for all API calls - TLS encryption for data in transit - Fail-safe mechanisms if connectivity is lost - Air-gapped operation capability for safety-critical systems ## Human-robot collaboration workflows Modern industrial environments increasingly combine automated and manual work. Managing these mixed workflows requires coordination between robot control systems and human task management. ### Common workflow patterns **Assembly operations** - Robots handle heavy lifting and precise positioning while humans manage delicate components requiring dexterity. **Quality inspection** - Automated measurement systems perform initial checks, routing exceptions to human inspectors for review. **Maintenance workflows** - Diagnostic routines generate data that maintenance teams use for troubleshooting and repair. ### Safety and compliance considerations Industrial robot deployments must follow relevant safety standards: - ISO 10218 (Robots and robotic devices - Safety requirements for industrial robots) - ISO/TS 15066 (Collaborative robots) - ANSI/RIA R15.06 (North American industrial robot safety) Documentation and audit trails help demonstrate compliance during safety assessments. ## Integration planning considerations When planning robot-workflow integration: ### Technical requirements - API access and authentication mechanisms - Network connectivity and bandwidth - Protocol translation capabilities - Edge computing or middleware needs - Data synchronization and latency requirements ### Organizational readiness - IT and operations team collaboration - Clear ownership of robot systems - Change management processes - Training for maintenance personnel - Incident response procedures ## Industry applications Robotics workflow management applies across various sectors: ### Manufacturing Automotive assembly, electronics production, material handling, CNC coordination, quality inspection systems ### Logistics and warehousing Autonomous mobile robots (AMRs), automated guided vehicles (AGVs), picking and packing systems, inventory management ### Healthcare Laboratory automation, pharmacy dispensing, sample tracking, diagnostic equipment coordination ### Food and beverage Packaging lines, batch processing, cleanroom operations, quality control systems ## Workflow management challenges ### Common integration challenges **Protocol complexity** - Translating between industrial protocols and business systems requires specialized middleware and expertise. **Network security** - Maintaining proper OT/IT segregation while enabling data flow. **Latency sensitivity** - Real-time robot control versus asynchronous workflow updates require different architectural approaches. **Legacy systems** - Older robot controllers may lack modern connectivity options. **Vendor lock-in** - Proprietary systems can limit integration flexibility. ### Documentation and knowledge management Organizations managing robot fleets face challenges in: - Maintaining up-to-date operational procedures - Sharing improvements across multiple robot installations - Tracking which procedures were followed for compliance - Managing procedure versions as operations evolve - Coordinating human and automated tasks effectively ## Robotics vendor resources This section includes vendor-specific documentation exploring workflow management considerations for different robot platforms: - **[Universal Robots](/products/pro/integrations/robotics/universal-robots/)** - Collaborative robot (cobot) platform - **[KUKA](/products/pro/integrations/robotics/kuka/)** - Industrial robot systems - **[Boston Dynamics](/products/pro/integrations/robotics/boston-dynamics/)** - Mobile inspection robots - **[Unitree Robotics](/products/pro/integrations/robotics/unitree/)** - Quadruped and humanoid platforms - **[AppTronik Apollo](/products/pro/integrations/robotics/apptronik/)** - Humanoid robot platform **Note**: These resources explore potential integration patterns and workflow management challenges. Specific implementation details depend on individual organizational requirements, robot configurations, and network architecture. ## Important disclaimer **Information currency**: This documentation provides general information about robotics workflow integration concepts and challenges. The robotics industry evolves rapidly, with frequent changes in: - Vendor product capabilities and APIs - Communication protocols and standards - Safety regulations and compliance requirements - Market positioning and company ownership **Verification required**: Before making any technical or business decisions: - Verify current vendor capabilities through official documentation - Consult with robot manufacturers for specific integration requirements - Review current safety standards and compliance obligations - Assess your organization's specific technical and operational needs **No guarantees**: This documentation does not constitute: - Promises of specific integration capabilities - Technical specifications or service level agreements - Endorsements of particular vendors or products - Professional advice for your specific situation Contact Tallyfy support to discuss your specific robotics integration requirements and current capabilities. - **[Open API](https://tallyfy.com/products/pro/integrations/open-api/)**: The Tallyfy REST API enables developers to build custom integrations with full platform functionality through three authentication methods (user tokens application tokens and OAuth) while providing comprehensive access to process management task operations user administration and data export capabilities with standard JSON responses and reasonable rate limits. ## Tallyfy REST API overview The Tallyfy REST API lets developers build custom connections to our core platform features through code-based integrations. Tallyfy's "API-first" approach means our public API gives you the exact same functionality that powers our web app - no second-class citizen treatment here. Everything we built for ourselves, you get too. This foundation guarantees stable APIs for your mission-critical integrations (because we depend on them just as much as you do). As an [independent platform committed to data portability](/products/pro/miscellaneous/about-tallyfy/), we ensure you always have full programmatic access to your workflows and data. ### Use cases for API integration API integration lets you embed Tallyfy functionality right into your existing business apps, automate complex workflows across multiple systems, and create completely customized user experiences. Instead of forcing people to context-switch between different systems, the API brings Tallyfy's capabilities into the tools your team already uses. ### API capabilities The API lets you build custom connections, automate workflows between Tallyfy and external systems, and extend platform functionality. :::note[Technical audience] This section contains technical information intended for developers or those collaborating with development teams. ::: ### API fundamentals | Environment | Base URL | Documentation Link | |-------------|---------------------------|----------------------------------------| | Production | `https://go.tallyfy.com/api/` | [Tallyfy API Reference](https://go.tallyfy.com/api/) | ### Authentication methods Tallyfy provides three secure authentication methods for programmatic API access: 1. **User Token Authentication**: Get a token for specific Tallyfy users (from their profile or through our API). Your app works with that user's exact permissions and access. - **Note**: Personal access tokens are invalidated when users log out. For stable, long-running automations, consider application tokens instead. 2. **Application Token Authentication**: Get app-level credentials (client ID & secret) so your application can act on behalf of multiple users. Perfect for server-to-server connections or multi-user apps. 3. **OAuth Authentication Flow**: The industry-standard secure way that lets users give your app access to their Tallyfy data without sharing passwords. Recommended for third-party apps. [Learn more](/products/pro/integrations/open-api/oauth-authorization-flow/). ### Required headers Every API request must include these mandatory headers: ``` Authorization: Bearer {your_access_token} // Your user or app token Content-Type: application/json // Tells Tallyfy you're sending JSON data X-Tallyfy-Client: APIClient // **Required** - Identifies the request source ``` :::caution[X-Tallyfy-Client Header is Mandatory!] Your code *must* include the `X-Tallyfy-Client: APIClient` header. Requests without it will fail with a 401. ::: ### Available API operations The API provides full access to core Tallyfy features, including: | Functional Category | Available API Operations | |-----------------------|---------------------------------------------------------| | **Process Management**| Launch processes, monitor status, cancel executions | | **Task Operations** | Complete tasks, update form data, manage comments | | **User Administration**| Create/manage users, configure roles & permissions | | **Template Control** | Create/update templates, manage steps & configurations | | **Data Access** | Export process data, retrieve analytics information | | **File Management** | Upload files, manage attachments and documents | ### API response format Tallyfy API responses follow standard conventions: - All data returns in structured JSON format for easy parsing. - Standard HTTP status codes indicate request outcomes (200 for success, 4xx/5xx for errors). - Error responses include detailed, actionable error messages. - List endpoints support pagination for efficient data retrieval. ### Rate limits Tallyfy enforces these rate limits: - **Per-minute limit**: Maximum 100 requests per minute (per organization) - **Per-hour limit**: Maximum 1,000 requests per hour (per organization) - **Rate limit monitoring**: API response headers indicate current usage and remaining capacity If you're hitting these limits regularly, implement caching or batching. Contact support for high-volume use cases. ### Getting started 1. **Get your API credentials**: Find your API keys/tokens at **Settings** > **Integrations** > **REST API** in Tallyfy. 2. **Check out our documentation**: Read through the official [API docs](https://go.tallyfy.com/api/) for detailed info on endpoints and how to use them. 3. **Look at code examples**: Check out practical examples on [Tallyfy's GitHub repo](https://github.com/tallyfy/api-support/) for different programming languages. :::note[Testing API Calls] Use standard developer tools like Postman, Insomnia, or command-line `curl` to test API requests. ::: ## Recommended next After understanding the API basics, we recommend these next steps: - Learn how to [integrate with Tallyfy using the API](/products/pro/integrations/open-api/how-to-integrate-with-tallyfy-using-api/) for detailed authentication and request examples. - If you're building a multi-user application, explore [API usage as a third-party application](/products/pro/integrations/open-api/access-api-as-a-third-party-application-instead-of-a-user/) to understand client credentials flow. - Check the [API code samples](/products/pro/integrations/open-api/code-samples/) for practical examples in various programming languages. - **[BYO AI (Bring Your Own AI)](https://tallyfy.com/products/pro/integrations/byo-ai/)**: BYO AI is Tallyfy's upcoming integration framework that connects existing AI subscriptions like ChatGPT Plus or Claude Pro directly into workflows so AI can automatically complete tasks and generate content without manual copy-pasting between applications. :::note[MCP Industry Standard] BYO AI uses MCP (Model Context Protocol), which has become the industry standard for connecting AI to business tools. In December 2025, MCP was donated to the Agentic AI Foundation under the Linux Foundation - co-founded by Anthropic, Block, and OpenAI, with AWS, Google, Microsoft, Cloudflare, and Bloomberg as supporting members. All major AI platforms now support MCP. ::: ## Connecting your AI subscription to automate Tallyfy workflows BYO AI (Bring Your Own AI) is Tallyfy's integration framework that connects your existing AI subscriptions - ChatGPT Plus, Claude Pro, Google Gemini, or Microsoft Copilot - directly into your workflows. Your AI becomes a team member that can complete tasks, write documents, analyze data, and make decisions right inside Tallyfy processes. Here's the reality: most people have AI subscriptions they barely use. They open ChatGPT occasionally, ask a question, then go back to manual work. BYO AI changes that. It embeds AI assistance into your actual workflow steps, so the AI works for you automatically, using the subscription you're already paying for. ### Why BYO AI matters for workflow automation Think about how AI typically gets used in organizations. Someone copies text from a document, pastes it into ChatGPT, waits for a response, then copies that response back into another system. It's manual, disconnected, and defeats the purpose of automation. BYO AI eliminates this copy-paste chaos. When a task lands in someone's queue, the AI can: - Read the task context and form field data - Execute based on your custom instructions - Complete the task or add detailed comments - Move the process forward automatically No prompt engineering skills needed. No switching between apps. The AI just works, right where the work happens. ### How BYO AI authentication works The magic happens through OAuth2 authentication - the same secure method you use when signing into websites with Google or Microsoft. Here's the flow: 1. **You authorize once**: Connect your AI account to Tallyfy through a secure OAuth flow 2. **Tallyfy stores tokens**: We securely store authentication tokens (never your password) 3. **AI acts on your behalf**: When triggered, Tallyfy sends instructions to your AI using your subscription 4. **Results flow back**: The AI's response automatically updates the task or completes the action Your AI subscription remains yours. We just provide the bridge between your workflows and your AI assistant. ### Supported AI platforms ### Key capabilities #### Task automation Your AI can automatically complete tasks based on: - Form field values from previous steps - Document attachments and their contents - Historical process data and patterns - Custom instructions you embed in templates #### Intelligent content generation Instead of blank form fields, users see AI-generated suggestions: - Draft emails based on process context - Generate reports from collected data - Create summaries of long documents - Translate content into multiple languages #### Decision support AI analyzes data and provides recommendations: - Risk assessment based on form responses - Approval recommendations with reasoning - Priority scoring for incoming requests - Anomaly detection in submitted data #### Process optimization AI learns from your workflow patterns: - Suggests process improvements - Identifies bottlenecks - Recommends task reassignments - Predicts completion times ### Common use cases **Document processing**: AI reads uploaded contracts, extracts key terms, and populates form fields automatically. No more manual data entry from PDFs. **Customer service**: AI drafts responses to customer inquiries based on your knowledge base and previous successful responses. Agents just review and send. **Compliance reviews**: AI checks submissions against your compliance rules, flags issues, and suggests corrections before human review. **Meeting follow-ups**: AI reads meeting transcripts, extracts action items, and creates follow-up tasks automatically in the right processes. **Data analysis**: AI analyzes spreadsheet uploads, generates insights, and creates summary reports without anyone touching Excel. ### Implementation status BYO AI is live and actively developed: **Phase 1 - Direct Integration** ✅ Available now - OAuth 2.1 connection to all major AI platforms (ChatGPT, Claude, Gemini, Copilot) - Task completion and commenting via natural language - MCP server with full tool support **Phase 2 - Advanced Automation** 🔄 In development - Multi-step AI workflows - Conditional AI actions based on responses - AI-to-AI handoffs between steps **Phase 3 - Learning & Optimization** 📋 Planned - AI learns from your process history - Suggests template improvements - Predictive automation ### Security and control Your AI, your data, your control: - **Subscription isolation**: Each organization uses their own AI subscription - **Data boundaries**: AI only accesses data from the specific process context - **Audit trails**: Every AI action is logged with inputs and outputs - **Human oversight**: Configure which tasks require human review - **Revocation**: Disconnect AI access instantly if needed ### Getting started BYO AI integration uses OAuth 2.1 with PKCE for secure authentication: 1. Configure your AI platform (ChatGPT, Claude Desktop, Google Gemini, or Microsoft Copilot) with Tallyfy's MCP server 2. Complete the OAuth authorization flow to connect your Tallyfy account 3. Grant permissions for the scopes your AI needs (tasks, processes, templates, users, read, write) 4. Your AI can now interact with Tallyfy using natural language **Technical endpoints** (live and operational): - MCP Server: `https://mcp.tallyfy.com` - OAuth Authorization: `https://go.tallyfy.com/mcp/oauth/authorize` - OAuth Token: `https://go.tallyfy.com/mcp/oauth/token` - Dynamic Client Registration: `https://go.tallyfy.com/mcp/oauth/register` - OAuth Metadata: `https://go.tallyfy.com/.well-known/oauth-authorization-server` **Available scopes**: `mcp:tasks`, `mcp:processes`, `mcp:templates`, `mcp:users`, `mcp:read`, `mcp:write` See the platform-specific guides below for detailed setup instructions. ### The future of work with BYO AI We're not replacing humans - we're amplifying them. BYO AI means your team focuses on decisions, relationships, and creative work while AI handles the repetitive, time-consuming tasks that slow everyone down. Your AI subscription becomes an actual team member, not just a chat window. It knows your processes, follows your rules, and gets work done. That's the promise of BYO AI. ### Related integration approaches While BYO AI focuses on connecting your existing AI subscriptions, Tallyfy offers other AI integration paths: - [Computer AI agents](/products/pro/integrations/computer-ai-agents/) for screen automation - [MCP server integration](/products/pro/integrations/mcp-server/) for developer-built AI tools - [API integration](/products/pro/integrations/open-api/) for custom AI implementations - [Webhook automations](/products/pro/integrations/webhooks/) for event-driven AI triggers - **[Vendors](https://tallyfy.com/products/pro/integrations/vendors/)**: Connect your existing business systems with Tallyfy to orchestrate cross-department workflows that vendor platforms cannot coordinate on their own - bridging CRM, Helpdesk, HR, Finance, RPA, and Operations teams. ## The orchestration layer your vendors need Your HR, Finance, and collaboration platforms excel at their core functions. But they cannot coordinate cross-department processes. When someone is hired in your HR system, IT needs to provision accounts. Facilities needs workspace setup. Training needs to schedule orientation. Finance needs expense configuration. These handoffs happen through email and manual tracking - not the vendor platform. Tallyfy fills this gap by orchestrating workflows across ALL your teams, not just within one vendor's ecosystem. ## How vendor integrations work When vendor events occur - new hire, payroll run, message shared - Tallyfy can launch structured workflows that: - Coordinate multiple departments automatically - Assign tasks with clear ownership and deadlines - Track progress across all stakeholders - Escalate when actions are delayed - Document completion for compliance ## Available vendor connections ## The gap Tallyfy fills **CRM systems** track deals through pipeline stages but cannot coordinate the micro-tasks between stages - proposal development, technical scoping, pricing approvals, contract reviews, and post-sale handoffs. **Helpdesk tools** capture tickets and conversations but cannot transform unstructured requests into structured process funnels with clear accountability, deadlines, and cross-team coordination. **HR systems** manage employee data but cannot coordinate IT provisioning, Facilities setup, or Training schedules when someone joins or leaves. **Finance systems** process transactions but cannot orchestrate multi-stakeholder approvals, month-end close coordination, or reconciliation workflows. **Communication tools** enable conversations but cannot ensure accountability, track action items, or enforce deadlines. **RPA platforms** automate repetitive tasks on screens but cannot orchestrate the human activities that happen before, during, and after bot execution. Exception handling, human approvals, and bot-human handoffs all require coordination. Tallyfy works WITH these vendors as the orchestration layer that coordinates processes spanning multiple teams and systems. ## CRM orchestration CRM platforms excel at tracking deals and customer relationships. But deals require more than tracking - they require coordinated tasks across multiple teams that CRMs cannot orchestrate. **What CRMs track:** - Pipeline stages and deal values - Customer interactions and communications - Sales activities and forecasts - Contact and account data **What Tallyfy adds:** - Micro-tasks between each sales stage - Cross-team proposal and contract workflows - Approval chains for pricing exceptions - Post-sale handoffs to Operations and Success - Audit trails for deal execution Learn more: [Integrate to your CRM or ERP](/products/pro/integrations/middleware/integrate-into-crm/) **CRM vendors:** - [Salesforce](/products/pro/integrations/vendors/salesforce/) - [HubSpot](/products/pro/integrations/vendors/hubspot/) - [Pipedrive](/products/pro/integrations/vendors/pipedrive/) - [Zoho CRM](/products/pro/integrations/vendors/zoho-crm/) - [Close](/products/pro/integrations/vendors/close/) - [Copper](/products/pro/integrations/vendors/copper/) ## Helpdesk orchestration Helpdesk platforms capture support tickets and conversations. But complex issues require more than replies - they require structured workflows that transform ticket chaos into process funnels. **What helpdesks capture:** - Support tickets and conversations - Agent assignments and SLAs - Customer communication history - Knowledge base articles **What Tallyfy adds:** - Structured multi-team resolution workflows - Escalation processes with enforced deadlines - Post-resolution follow-up sequences - Root cause analysis workflows - Product improvement tracking Learn more: [Tickets vs. Processes](/products/pro/tutorials/features/ticket-driven-vs-process-driven/) **Helpdesk vendors:** - [Zendesk](/products/pro/integrations/vendors/zendesk/) - [Freshdesk](/products/pro/integrations/vendors/freshdesk/) - [Intercom](/products/pro/integrations/vendors/intercom/) - [ServiceNow](/products/pro/integrations/vendors/servicenow/) - [Jira Service Management](/products/pro/integrations/vendors/jira-service-management/) - [Help Scout](/products/pro/integrations/vendors/help-scout/) ## RPA orchestration RPA platforms like UiPath, Automation Anywhere, and Blue Prism excel at automating repetitive, rule-based tasks. But most processes require BOTH automated AND human activities. Tallyfy provides the orchestration layer that connects bots with human workflows. **What RPA automates:** - Screen scraping and data extraction - Form filling and data entry - Rule-based decisions - Legacy system interactions **What Tallyfy adds:** - Human-bot handoffs and exception routing - End-to-end process visibility - Accountability for process outcomes - SLA tracking across automated and manual steps Learn more: [Combining RPA systems and human operators](/products/pro/integrations/open-api/how-does-tallyfy-combine-rpa-systems-and-human-operators/) ## Connect today **Middleware platforms** are the fastest path to connection: - [Zapier](/products/pro/integrations/middleware/zapier/) - Simple automation - [Power Automate](/products/pro/integrations/middleware/power-automate/) - Microsoft ecosystem - [Make](/products/pro/integrations/middleware/make/) - Visual workflows - [Workato](/products/pro/integrations/middleware/workato/) - Enterprise automation **API integration** for custom requirements: - [Tallyfy Open API](/products/pro/integrations/open-api/) - Build direct connections - [Webhooks](/products/pro/integrations/webhooks/) - Event-driven automation - **[Webhooks](https://tallyfy.com/products/pro/integrations/webhooks/)**: Tallyfy webhooks automatically send JSON data to external systems when workflow events occur enabling instant integration with middleware platforms custom APIs and serverless functions without requiring constant polling. ## How do Tallyfy webhooks enable real-time system integration and automation? Webhooks give you automatic, real-time data transmission that sends structured JSON messages from Tallyfy to external systems whenever specific events happen in your workflows. These smart automated notifications eliminate the need for constant system polling while letting you respond immediately to critical workflow events like task completions, process launches, or status changes. Webhooks transform Tallyfy from an isolated workflow system into a reactive automation hub that triggers actions across your entire technology ecosystem. :::tip[Webhooks = Automatic Doorbell/Notification] Think of a webhook like an **automatic doorbell** for your other software: - When a specific **event occurs** in Tallyfy (like a task is completed - someone **presses the doorbell**), - Tallyfy instantly sends a **notification** (the webhook message, with details about the event) to a web address (URL) you specify. - The other system listening at that address (**hearing the doorbell**) receives the message immediately. This allows other systems to react in real-time to things happening in Tallyfy, without needing to constantly check for updates. ::: Any system that can receive standard web requests (HTTP POST) can receive Tallyfy webhooks. ### What advantages do Tallyfy webhooks provide for business automation? - **Instant data delivery**: Get complete information right away when events happen in Tallyfy workflows for real-time responses. - **Standardized format**: Webhooks always use industry-standard JSON format so they work with any system. - **Universal compatibility**: Connect easily to virtually any system that can receive HTTP web requests for maximum flexibility. - **Automated action triggering**: Start workflows or actions in external systems automatically based on specific Tallyfy events for complete automation. These advantages let you create responsive, connected systems that react smartly to workflow events. ### What systems commonly receive Tallyfy webhooks for integration? Webhooks are commonly sent to different types of systems: - **Middleware platforms** (like Zapier, Make, Power Automate) that smartly route data to other apps for multi-system coordination. - **Custom APIs and applications** that you build for specific business needs and specialized processing. - **Serverless functions** (like AWS Lambda, Azure Functions) for scalable, event-driven processing without managing infrastructure. - **RPA bots** (Robotic Process Automation) for automated task execution in legacy systems that lack modern APIs. This flexibility means webhooks can work with virtually any business system setup. :::note[Choosing How to Use Webhooks] Sending webhooks to middleware (Zapier, Make, etc.) is usually the easiest way to connect Tallyfy events to other apps without coding. Building your own custom webhook receiver gives you the most control but requires development resources. ::: #### Primary webhook destination categories: - **Integration middleware platforms** (Zapier, Power Automate, Make.com) for connecting systems - **Custom API endpoints** for customized business logic - **Serverless functions** (AWS Lambda, Azure Functions) for scalable event processing - **RPA solutions** (Robotic Process Automation) for automating legacy system interactions - **Custom scripts and applications** for specialized business needs :::note[Considering Integration Alternatives] While Zapier can be useful for simple connections, we generally recommend more capable and cost-effective middleware solutions like **n8n**, **Make**, or **Microsoft Power Automate** for serious integrations. For maximum control and flexibility, especially if you have development resources, consider using Tallyfy's [Open API](/products/pro/integrations/open-api/) to build custom integrations that use AI to generate code for serverless functions. ::: For detailed implementation instructions, see the articles linked below. ### Azure translation - **[Translation requirements for process documentation](https://tallyfy.com/products/pro/integrations/azure-translation/global-workplace-language-requirements/)**: Organizations operating across multiple countries must navigate varying workplace language requirements ranging from strict legal mandates in places like France Quebec UAE and Saudi Arabia where local language documentation is legally required to jurisdictions like Australia and the UK where English-only documents are perfectly acceptable. ## Where do laws or recommendations exist to translate process content to local languages? Important note - this article is not legal advice of any kind. You need to do your own research and use this content at your own risk. If you're running operations across multiple countries, language requirements can quickly become a compliance nightmare. Some countries fine you for English-only documents. Others just recommend translations. This guide maps out exactly which jurisdictions require workplace content in local languages - and which ones let you slide with English. Here's what you need to know: Organizations using workflow platforms like Tallyfy must ensure their templates and SOPs meet local language laws. Miss this, and you could face fines or unenforceable contracts. ### What types of workplace content are subject to language requirements? These are the main categories of workplace documentation that different countries regulate: - **Employment contracts and agreements** - **Standard Operating Procedures (SOPs) and work instructions** - **Safety procedures and training materials** - **Employee handbooks and policies** - **Disciplinary procedures and codes of conduct** - **Form fields and data collection instruments** - **Process templates and workflow documentation** - **Training content and instructional materials** Translation requirements vary wildly. France will fine you for English-only handbooks. Australia? They don't care. The spectrum runs from strict legal mandates to gentle suggestions that you help employees understand what they're reading. ## North America ### Canada (Federal) **Requirement Level:** Mandatory (public sector); No specific law (private sector) **Applies to:** Public sector (federal government); Private sector has no specific requirements **Requirements:** The federal Official Languages Act mandates bilingual English and French communication in federal institutions. Federal employees in designated bilingual regions have the right to work and receive documents in their official language of choice. Private-sector workplaces outside Quebec have no translation requirements. [2] ### Canada – Québec **Requirement Level:** Mandatory **Applies to:** All employers (private and public) in Quebec **Requirements:** The Charter of the French Language (Bill 96) mandates French as the language of work. All written communications to employees - including offers, contracts, policies, and training materials - must be provided in French unless an employee specifically requests another language. Pre-existing English documents had to be translated by June 1, 2023. This requirement applies even if only one employee is in Quebec. Non-compliance can result in fines. [1] ### Canada – Other Provinces **Requirement Level:** No specific law (use official language) **Applies to:** Private sector (English or French by practice); Public sector (bilingual in New Brunswick) **Requirements:** No province outside Quebec requires employee documents in a language other than English. Documents are typically in English or French in francophone areas. New Brunswick mandates bilingual public services but has no specific translation requirement for private employers' internal documents. [2] ### United States (Federal) **Requirement Level:** Mandatory for safety/rights information comprehension; no blanket requirement otherwise **Applies to:** Private and public sectors (for OSHA and federal notices) **Requirements:** No general law requires workplace document translation, but employers must convey certain information in a language employees understand. OSHA regulations require safety training and hazard communications in comprehensible language and vocabulary. Federal notices (EEOC, FMLA posters) are available in Spanish and other languages - employers are encouraged or required to use them if a significant workforce portion isn't English-fluent. English-only workplace policies cannot be enforced if they impede employee rights (per EEOC rules). [3] ### United States – States **Requirement Level:** Mandatory for specific notices (varies by state); Recommended for other documents **Applies to:** Private and public sectors (state-level requirements) **Requirements:** California's Labor Code §2810.5 requires new-hire wage/hour notices in "the language the employer normally uses to communicate employment-related information" with the employee. California and states like New York mandate certain posters or notices in Spanish and other languages if threshold percentages of workers aren't English-proficient. While most US employment documents are in English, employers are strongly advised to provide translations (especially Spanish) for handbooks, safety training, and key policies when large portions of employees are non-English speakers. [4] ### Mexico **Requirement Level:** Mandatory (contracts and official documents in Spanish); Recommended (policies/SOPs) **Applies to:** Private and public sectors **Requirements:** Spanish is the official language for employment relations. Employment contracts should be in Spanish to be legally valid, with Spanish versions prevailing in legal effect. Authorities require all employment documents submitted to labor authorities or courts be in Spanish or accompanied by official translation. Many companies provide bilingual Spanish-English contracts and handbooks, but Spanish text is binding. No statutory requirement exists for day-to-day communication translation, but Spanish versions of policies and safety instructions are strongly recommended for employee comprehension. [5] ### Other North America **Requirement Level:** No specific translation laws (default to official language) **Applies to:** Private and public sectors **Requirements:** Central America and Caribbean countries (Guatemala, Honduras, El Salvador, Dominican Republic, etc.) use their official language - Spanish in most cases, French in Haiti, English in some Caribbean states - for all employment contracts and internal documents. No specific laws mandate translation beyond the official/national language. Panama and Costa Rica generally require Spanish for labor matters; English documents should be translated if reviewed by authorities. Employers typically provide documentation in the official language. [12] ## Europe ### France **Requirement Level:** Mandatory (French must be used for all employee documents) **Applies to:** Private and public sectors (labor code covers employment relationships) **Requirements:** The Toubon Law and Labor Code Article L.1321-6 require all documents setting out employee obligations or necessary instructions to be in French. This includes employment contracts, policies, codes of conduct, collective agreements, and even software interfaces or manuals used by employees. No clause in a foreign language can be enforced against an employee. Courts are very strict - employers have been fined for issuing English-only handbooks in France. Translations may be attached, but French is authoritative. [6] ### Belgium – Flanders (Dutch-speaking) **Requirement Level:** Mandatory (Dutch only) **Applies to:** All employers (private and public) in the region **Requirements:** Belgian regional language laws require all employment documents and communications with employees in the Flemish region be in Dutch. Documents in another language are deemed null and void against the employer. Employees could still invoke an English clause in their favor, but employers cannot enforce it. Official work rules and contracts must be in Dutch; unofficial English translations can be provided for convenience. [7] ### Belgium – Wallonia (French-speaking) **Requirement Level:** Mandatory (French only) **Applies to:** Private and public sectors **Requirements:** All employment documents in the Walloon region must be in French. Using another language with employees is prohibited, and documents not in French are legally null and void. As in Flanders, an English version can be given for reference but has no legal force. [7] ### Belgium – Brussels (Bilingual) **Requirement Level:** Mandatory (French or Dutch depending on employee) **Applies to:** Private and public sectors **Requirements:** Employment language follows the employee's language (assumed French or Dutch). Documents may be in French for Francophone employees and Dutch for Dutch-speaking employees. Employers in Brussels often provide documents in both languages. Unlike Flanders/Wallonia, the sanction for using wrong language isn't nullity; instead, employees can demand translation at employer's expense. [7] ### Luxembourg **Requirement Level:** No mandatory language law (mutual understanding required) **Applies to:** Private and public sectors **Requirements:** No specific statutory requirement regarding employment document language. In practice, contracts and policies are usually in official languages (French, German, or Luxembourgish) or English - as long as both employer and employee understand the language used. Documents in an official language (or bilingual) are recommended for local employees. English-only contracts are common for international staff, but translations may be provided for clarity. [8] ### Germany **Requirement Level:** No explicit requirement (best practice to use German) **Applies to:** Private and public sectors (German is de facto for public sector) **Requirements:** German law doesn't mandate employment documents be in German. English contracts are lawful if both parties understand them. However, it's customary and prudent to provide German versions for German-speaking employees to avoid misunderstandings. Courts hold that employees must comprehend workplace rules; key instructions (safety, disciplinary rules) should be explained in German if workers aren't fluent in the foreign language. Translation is recommended as best practice but not legally required in private sector. Public sector generally requires German for official documents. [11] ### Netherlands **Requirement Level:** No specific law (ensure employee understanding) **Applies to:** Private and public sectors **Requirements:** Dutch law doesn't require employment contracts or policies in Dutch. Employers may draft documents in English or another language if employees are comfortable with it. International companies often use English contracts. However, if workers don't understand a document's language, employers must provide explanation or translation to ensure employees are aware of their rights and obligations. In legal disputes, courts consider whether employees could comprehend terms. Providing Dutch translations is recommended to avoid ambiguity. [8] ### Spain **Requirement Level:** Mandatory (Spanish for contracts; local language or bilingual as needed) **Applies to:** Private and public sectors **Requirements:** Spanish labor law requires employment contracts for Spanish employees be in Spanish (Castilian). Employers can provide bilingual contracts (Spanish-English), but Spanish text governs in case of conflict. Other employment documents (handbooks, safety instructions) should also be in Spanish for full effectiveness, though translations in other languages can be added. In some autonomous regions (Catalonia, Basque Country), local co-official languages may be used in addition to Spanish, but Spanish is generally sufficient legally. [10] ### Italy **Requirement Level:** No specific requirement (Italian is standard; translation strongly advised) **Applies to:** Private and public sectors (public sector uses Italian) **Requirements:** Italian law doesn't explicitly require Italian-language employment contracts or policies for private companies. Contracts may be in a foreign language if both parties understand it. However, it's strongly recommended to draft documents in Italian (or provide Italian translations) when employing local staff, because all legal proceedings and official dealings will be in Italian. In disputes, courts might favor Italian text interpretation or require certified translation of foreign-language documents. Public sector and official documents are always in Italian. [8] ### Poland **Requirement Level:** Mandatory (Polish required; bilingual allowed) **Applies to:** Private and public sectors **Requirements:** The Polish Language Act (amended 2011) imposes statutory requirement to prepare employment documents in Polish for them to be binding. Employment contracts, agreements, and internal work regulations must be in Polish (though bilingual versions are allowed). If bilingual versions are used, Polish text prevails in case of discrepancies. Employees may request documents in another language in addition to Polish, but Polish remains the legal reference. Foreign employees who don't speak Polish are generally given unofficial translations for convenience, but the official version is Polish. [9] ### Czech Republic **Requirement Level:** No specific law (Czech used customarily) **Applies to:** Private and public sectors **Requirements:** No law requires Czech language for employment documents. The Labor Code allows agreements in other languages if both parties agree and understand them. In practice, most employment contracts and policies with local staff are in Czech to ensure understanding and compliance with Czech labor standards. Providing documents in Czech is highly recommended, especially since court or authority proceedings need Czech versions. Official communications to government must be in Czech. [8] ### Hungary **Requirement Level:** No specific law (use Hungarian for clarity) **Applies to:** Private and public sectors **Requirements:** Hungarian law doesn't mandate Hungarian language use in employment contracts or internal policies. Employers and employees are free to choose another language if mutually understood. However, since Hungarian employees have a right to understand their working conditions, employers usually provide documents in Hungarian. Authorities and courts require Hungarian translations of foreign-language documents in official processes. While not mandatory by statute, using Hungarian or bilingual documents is the norm. [8] ### Romania **Requirement Level:** Mandatory for contracts (Romanian); others recommended **Applies to:** Private and public sectors **Requirements:** Under the Labor Code, individual employment contracts must be concluded in Romanian (even if foreign language versions are also provided). However, accompanying documents (internal rules, job descriptions) aren't legally required to be in Romanian as long as employees understand them. In practice, most HR documents are in Romanian. For foreign staff, companies might use bilingual formats. The key point is that main contracts are in the national language. [8] ### Slovenia **Requirement Level:** Mandatory (Slovenian required) **Applies to:** Private and public sectors **Requirements:** All employment documents (contracts, policies, internal instructions) must be in Slovenian by law. They may be bilingual, but Slovene must be one of the languages. Even internal communications related to employees' rights and safety must be conducted in Slovene. This is strictly enforced; documents not in Slovenian could be deemed non-compliant. Employers typically provide a Slovenian version with translations as needed. [8] ### Austria **Requirement Level:** No specific law (German by practice) **Applies to:** Private and public sectors **Requirements:** Austrian law doesn't require German for employment documents, but it's implicitly expected. In practice, virtually all employment contracts and workplace policies are in German (Austria's official language). English or other language contracts aren't per se invalid if employees fully understand them, but required filings (with authorities) must be in German. To avoid disputes about comprehension, using German or bilingual format is advised. Public sector employment is conducted in German by law. [8] ### Other Europe **Requirement Level:** Varies; mostly no mandatory rule (default to official language or mutual understanding) **Applies to:** Private and public sectors **Requirements:** **Switzerland:** No nationwide rule for private sector; companies use local official language (German, French, or Italian depending on canton) for employee documents, or English in international settings if employees agree. **Nordic Countries (Sweden, Norway, Denmark, Finland):** No legal mandates to use local language in contracts, but generally documents are in Swedish/Norwegian/etc. for native employees. If foreign language is used, employers should ensure employees understand terms (some countries like Finland explicitly state employees must be briefed in a comprehensible language). **United Kingdom/Ireland:** No requirement to translate policies (English is working language). However, providing translations for immigrant workers (Polish, Urdu speakers in UK) is considered good practice for health, safety and equality reasons. **Eastern Europe (Baltics, Balkans not listed above):** In many cases, official language is required for official filings and strongly recommended for contracts, but not always explicitly mandated by statute. For all these countries, no specific translation laws exist beyond the expectation that official or predominant local language is used so employees understand information. [12] ## Asia-Pacific ### China **Requirement Level:** De facto mandatory (Chinese needed for legal enforceability) **Applies to:** Private and public sectors (official dealings in Chinese) **Requirements:** Chinese labor laws don't explicitly state "contracts must be in Chinese," but in practice Chinese (Mandarin) is required for legal and administrative purposes. All employment contracts should be executed in Chinese for legal certainty, as Chinese language contracts are generally required if disputes go to Chinese courts or documents are submitted to government agencies. Companies often sign bilingual Chinese-English contracts; however, the Chinese version will prevail legally. Internal regulations and manuals should be in Chinese or translated, since employees must comprehend them. Many multinationals provide dual-language handbooks in China. [13] ### Japan **Requirement Level:** No explicit requirement (Japanese strongly recommended; ensure foreigners get translations) **Applies to:** Private and public sectors (public sector uses Japanese by law) **Requirements:** Japan has no specific law forcing Japanese use in private employment contracts or policies. However, because most employees are Japanese-speaking and labor disputes are handled in Japanese, it's standard practice to provide all employment terms in Japanese. Government guidance encourages that non-Japanese workers be given contracts and work rules in a language they understand (English, Portuguese for Brazilians in Japan, etc.). While not mandated, Japanese is effectively the default language for workplace documents. Foreign companies operating in Japan often prepare bilingual documents (Japanese and English) to ensure mutual understanding. [8] ### South Korea **Requirement Level:** No specific law (Korean expected in practice) **Applies to:** Private and public sectors **Requirements:** No law explicitly requires Korean-language contracts in private sector, but Korean is the normal working language. Employment contracts, handbooks, and notices are usually in Korean. If employers provide English contracts to local employees, courts will examine whether employees truly understood them; Korean translations may be demanded in disputes. For compliance (submitting rules to authorities or for litigation), Korean versions are required. Therefore, employers should translate all key documents into Korean. [12] ### India **Requirement Level:** No nationwide requirement (state laws on notices in local languages; ensure understanding) **Applies to:** Private and public sectors (state-specific in public sector too) **Requirements:** India has no single official language nationally (the constitution recognizes Hindi and English for official purposes). Labor laws don't mandate a particular language for employment documents across private sector. English is commonly used for contracts and policies in Indian private companies. However, many states require certain notices (standing orders, factory safety instructions) be displayed in local regional language (Hindi, Bengali, Tamil, etc.) so workers understand them. While employment contracts in English are valid, employers must ensure all employees comprehend workplace rules - which often means providing translations or explanations in local language for blue-collar workers. Government forms and public-sector employment use Hindi or relevant state language (with English translations). [12] ### Australia **Requirement Level:** No requirement (English is standard) **Applies to:** Private and public sectors **Requirements:** Australia has no laws requiring translation of employment documents into other languages. English is the de facto language of business and employment. Even for immigrant workers, there's no statutory duty for employers to provide materials in their native language - the onus is on employees to have sufficient English or ask for clarification. For safety training, employers must ensure communication is effective, which may involve translation or interpreters if language barriers exist. The absence of legal mandate notwithstanding, some large employers choose to translate key policies into languages like Chinese or Arabic as best practice. Overall, providing documents in English is sufficient under Australian law. [12] ### New Zealand **Requirement Level:** No requirement **Applies to:** Private and public sectors **Requirements:** New Zealand similarly has no requirement to translate employment documents. English (and Māori in some public contexts) is used for employment contracts and workplace policies. There are provisions ensuring employees understand health and safety instructions - for instance, if workers have limited English, employers should take reasonable steps to communicate in a way that person understands (which could include translation). But there's no specific statute compelling written translations. Generally, English documents are legally valid; translations to other languages are optional and done as needed for understanding. [12] ### Indonesia **Requirement Level:** Mandatory (Indonesian required; bilingual allowed with Indonesian as official) **Applies to:** Private and public sectors **Requirements:** Indonesian language law (Law No. 24/2009) requires any agreement involving an Indonesian party be in Bahasa Indonesia. This means employment contracts with Indonesian employees must have an Indonesian version. If a foreign party is also involved (expat employee or foreign employer entity), the contract may be bilingual (Indonesian and English), but Indonesian text is authoritative. In recent guidance, Indonesia's Supreme Court opined that absence of an Indonesian version won't automatically void a contract if no bad faith is involved - but prudently, employers must comply and issue Indonesian-language contracts. All internally used documents like company regulations must be in Indonesian as well (with translations permissible alongside). [14] ### Malaysia **Requirement Level:** No specific requirement (Malay official in public sector; flexible in private) **Applies to:** Private and public sectors **Requirements:** Malaysia's laws don't mandate a particular language for private employment contracts - English is widely used in business and acceptable legally, as is Malay (Bahasa Malaysia). In public sector and official dealings, Malay is the official language. Generally, companies ensure local employees are given Malay versions of key documents, especially for lower-wage roles. Many firms use dual-language (Malay/English) contracts. Critical employee communications (safety rules, etc.) should be explained in Malay if workers aren't fluent in English. No penalty is specified for using English only, but understanding is key under Occupational Safety guidelines. [12] ### Singapore **Requirement Level:** No requirement (English is default business language) **Applies to:** Private and public sectors **Requirements:** Singapore has four official languages (English, Mandarin Chinese, Malay, Tamil), with English as the main working language. There's no legal requirement to translate employment materials into other languages; English employment contracts and handbooks are the norm. The government publishes some advisories and mandatory notices in multiple languages (safety posters in English, Chinese, Malay, Tamil), and employers are encouraged to communicate with workers in a language they understand (especially in construction/domestic work sectors). But legally, an English document suffices. Translations may be provided on a voluntary basis for convenience. [12] ### Other Asia-Pacific **Requirement Level:** Varies (Vietnam/Thailand: Mandatory local language; others: recommended) **Applies to:** Private and public sectors **Requirements:** **Philippines:** English is an official language and almost all employment documents are in English; no translation law required. **Vietnam:** Labor code requires contracts with Vietnamese employees be in Vietnamese (or bilingual with Vietnamese) to be enforceable; similarly, internal labor regulations must be in Vietnamese. **Thailand:** Thai labor law expects employment agreements to be in Thai if with Thai staff; while not explicitly mandatory, Thai versions are needed for any official filings or disputes. **Middle East (see next section)**. For most other Asian countries not listed, the general pattern is that official national language should be used for employment communications to avoid legal issues, but specific translation mandates (beyond ensuring employee comprehension) are uncommon. Always consider local official language as authoritative text for legal purposes. [12] ## Middle East & Africa ### United Arab Emirates **Requirement Level:** Mandatory (Arabic, with English translation optionally) **Applies to:** Private and public sectors (government forms in Arabic) **Requirements:** UAE labor law requires employment contracts to be in Arabic (the official language). In practice, contracts are typically bilingual Arabic-English, but the Arabic text is the legally binding version. All filings with the Ministry of Human Resources must be in Arabic. Employers must also post any required workplace notices (labor law abstracts) in Arabic. While workplace policies can be provided in English as well, an Arabic version is needed for any official purposes or if requested by the employee. [15] ### Saudi Arabia **Requirement Level:** Mandatory (Arabic required) **Applies to:** Private and public sectors **Requirements:** Employment in KSA is conducted in Arabic by law. The Labor Law states that documents (including contracts, disciplinary rules, etc.) shall be in Arabic. Like the UAE, companies often have dual-language contracts (Arabic/English), but Arabic prevails legally. Any memorandum or policy not in Arabic may not be recognized by authorities. Employers are advised to provide workplace instructions (safety, etc.) in Arabic to all workers; for foreign workers who don't speak Arabic, typically an interpreter or translated copy is provided in addition (though not legally mandated). [12] ### Israel **Requirement Level:** No specific requirement (Hebrew standard; ensure comprehension) **Applies to:** Private and public sectors (public sector bilingual) **Requirements:** Israel has two official languages (Hebrew and Arabic), with Hebrew dominant in most workplaces. There's no specific labor law forcing translation of documents, but employers must clearly inform employees of their employment terms in a language they understand (this is a principle under case law). In practice, Hebrew employment contracts and policies are standard. For Arab-Israeli employees or others who aren't Hebrew-proficient, providing Arabic or English versions is best practice to avoid claims of lack of notice. Official employment forms (for government filings) are in Hebrew (sometimes Arabic). Public sector institutions often issue bilingual Hebrew-Arabic materials. [12] ### South Africa **Requirement Level:** No requirement (multilingualism respected; oral interpretation if needed) **Applies to:** Private and public sectors **Requirements:** South Africa has 11 official languages, but English is the primary language of business and law. There's no statute requiring translation of employment documents into all or any specific language. Employers typically use English for contracts and policies. However, the law and Constitution emphasize the right to use official languages and require that procedures like disciplinary hearings be explained in a language the employee understands (interpreters provided if needed). Thus, key communications should be translated or interpreted for employees who aren't fluent in English or Afrikaans. Still, written documents can be in English by default without violating any law. [12] ### Kenya / Nigeria (example) **Requirement Level:** No specific requirements (use official colonial language in documentation) **Applies to:** Private and public sectors **Requirements:** These African nations use English as an official language (alongside local languages). No specific labor laws compel translation of documents into indigenous languages. Employment contracts and HR policies are usually in English. Employers are expected to explain terms and safety rules in Kiswahili, Hausa, or other local languages if workers have limited English, but this is a matter of practice, not explicit legal mandate. French-speaking African countries (Senegal, Côte d'Ivoire) similarly use French for all official and employment matters, following the principle that the official language governs. We did not find specific laws in these countries requiring additional translations beyond the official language. [12] ### Other Middle East & Africa **Requirement Level:** No broad translation mandates (use official language) **Applies to:** Private and public sectors **Requirements:** **Egypt, Morocco, Jordan, etc.:** Arabic is the official language and generally required for employment contracts and official documents (Egypt's labor law mandates Arabic contracts; Morocco requires French or Arabic for certain notices, with Arabic gaining prominence legally). **Francophone Africa:** French is treated as the default language for employment documentation (Ivory Coast, Cameroon - French contracts are standard). **East Africa:** English (and Swahili in Tanzania/Kenya) serves as the working language; no special translation laws. **Overall**, employers in these regions should use the official language(s) for written documents to ensure enforceability. No country in our research explicitly required providing internal policies in multiple languages by law except as noted above. Where employees speak minority languages, translations are a matter of policy or collective agreement rather than statute. [12] ### How does Tallyfy help organizations meet global language requirements? Tallyfy's [Azure AI-powered content translation](/products/pro/integrations/azure-translation/) tackles this compliance headache by automatically translating workflow content into 100+ languages. Here's what it does for you: - **Maintain compliance** with local language laws - your process templates and step instructions automatically appear in the right language - **Ensure employee comprehension** of safety procedures across multilingual teams (yes, it's that straightforward) - **Reduce translation costs** - real-time translation beats paying for manual document translation every time - **Scale globally** without juggling dozens of template versions in different languages - **Adapt quickly** when regulations change - update once, and it translates everywhere Smart design here: The system keeps your original language version as the authoritative one while translating everything else. That way you're covered when French law says "the French version rules" or when the UAE demands Arabic takes precedence. ### What are the key compliance considerations for global organizations? After digging through all these requirements, here's your strategic playbook: 1. **Identify mandatory vs. recommended jurisdictions** - Put your money where the fines are. Countries like France, Belgium, Quebec, UAE, and Saudi Arabia don't mess around. 2. **Establish authoritative language versions** - Most places let you go bilingual, but they're crystal clear about which version wins in court 3. **Ensure employee comprehension** - Look, even if the law doesn't require it, making sure your warehouse workers understand safety procedures in their language just makes sense 4. **Plan for enforcement variation** - France and Belgium will nail you. Other countries have laws on the books but rarely enforce them. Know the difference. 5. **Consider sector differences** - Working with government? Expect stricter rules. Running a factory? Safety translations aren't optional. 6. **Monitor regulatory changes** - These requirements keep shifting, especially around pay transparency and AI in the workplace ### Sources [1] Compliance Works, *"French Language Laws Triggered by 1 Québec Employee."* – summarizing Quebec's Charter of the French Language requirements (Bill 96) that all written communications (offers, contracts, policies, training docs) to Québec employees must be in French. [2] Morningside (Lexology), *"Are Employers Required to Translate Employment Documents? Key Regulations…"* – notes that Quebec has strict French documentation rules, while other Canadian provinces have no such stringent requirements. [3] OSHA Standard Interpretation – *"OSHA Training Standards Policy Statement,"* OSHA.gov – confirms employers must train and instruct employees in a language they understand (e.g. *"if an employee does not speak English, instruction must be provided in a language the employee can understand."*). [4] California DIR – *"Wage Theft Prevention Act FAQ."* California Dept. of Industrial Relations – Labor Code §2810.5 notice *"must be in the language the employer normally uses to communicate with the employee."*. Also, GovDocs summary of multi-language posting laws – e.g. California, New York requirements for Spanish postings. [5] Geos International, *"Navigating Employment Law in Mexico."* – notes Mexican authorities require employment contracts in Spanish; if a translated version exists, the Spanish version governs. Also, DLA Piper Guide – *"Spanish is recommended as all employment documents must be in Spanish or translated into Spanish."* [6] Norton Rose Fulbright, *"Ten Things to Know about Employment Law in France,"* §07 – *"The use of French language is mandatory: Any documents setting rights and obligations for employees must be prepared in French…courts are very strict on this principle."* [7] DLA Piper, *"Belgium: Use of Languages in Employment – At a Glance."* – explains regional language laws: Dutch mandatory in Flanders; French mandatory in Wallonia; in Brussels, use French or Dutch per worker's language, and employees can request translations. Also BusinessBelgium.be *"Work Regulations – Language"* (Payroll Pitfall) – *"In Flemish Region, documents must be in Dutch; in Walloon, in French; sanction is nullity."* [8] Wolf Theiss, *"Employment Brief – Language of Employment Documents in CEE/SEE."* – notes *"laws of Austria, Bulgaria, Croatia, Czech Republic, and Hungary do not require creation of employment documents in the national language"*, whereas *"in Slovenia, all documents must be in Slovenian"* and *"in Romania, the employment agreement must be in Romanian but accompanying documentation need not be."* Also PwC Legal for Luxembourg – *"No rules established regarding use of languages in contracts; recommended to use language understood by both."* [9] DLA Piper "Going Global" Guide – **Poland** – *"Statutory requirement to draft employment-related documents in Polish…bilingual version possible, but Polish version prevails."* [10] Zafo Law, *"Spanish Employment Contracts."* – *"Any Spanish employment contract has to be written in Spanish…two languages possible, but Spanish shall prevail."* [11] Morningside (Lexology) – notes for **Germany**: no legal requirement to translate, but doing so can prevent misunderstandings. Also, ACC, *"Global Communications Compliance."* – e.g. *"Belgium prohibits foreign-language HR documents; Germany doesn't legally require German, but recommended."* [12] **International surveys and law firm blogs** – Polsinelli at Work notes *"some countries (Australia, Switzerland) have no translation requirements"*; PosterGuard/GovDocs summaries for Latin America and others; Ius Laboris guides for various countries; local legal experts' Q&A on forums (e.g. Luxembourg, Portugal) confirming no mandatory language laws. These sources collectively indicate that in the **UK, Ireland, Australia, New Zealand, most of Africa, and many APAC countries**, there are *no specific statutes* compelling translation of employee documents (beyond using the official language or ensuring comprehension). We rely on these high-level authorities for countries where no explicit regulation was found. [13] China Briefing (Dezan Shira & Associates), *"Labor Laws in China – Language of Labor Contract."* – *"All labor contracts should be executed in Chinese language for legal certainty."* [14] Baker McKenzie, *"Statutory obligation to use Indonesian language in contracts"* – cites **Article 31, Law 24/2009**: *"Indonesian must be used in MOUs or agreements involving an Indonesian party"* (contracts with foreign parties can be bilingual Indonesian & English). [15] Darwinbox HR Blog, *"Essential Guide to UAE Labour Contracts."* – *"The labour contract must be written in Arabic, with an English translation for non-Arabic speakers."* Also UAE Labour Law (Federal Decree 33) which in practice is implemented via dual-language contracts (Arabic required for submission). - **[How to set up Azure Cognitive AI integration](https://tallyfy.com/products/pro/integrations/azure-translation/how-to-set-up-azure-cognitive-ai-integration/)**: This guide walks through setting up Microsoft Azure AI Services for Tallyfy's content translation feature including creating an Azure account and Translator resource then retrieving API credentials and configuring the integration within Tallyfy's settings before verifying the connection works properly. ## Preparing for Azure AI integration You need Microsoft Azure AI Services to enable Tallyfy's content translation feature. This takes about 15 minutes to set up. We'll walk through everything - from creating an Azure account to getting translation working in Tallyfy. ### Requirements Here's what you'll need: - Administrator access to your Tallyfy organization - Access to create or manage an Azure account - Permission to create Azure AI Services resources - Basic understanding of API keys and service endpoints ### Step 1: Azure account setup If you don't already have an Azure account: ### Step 2: Create a Translator resource With your Azure account ready, let's create the translation service: ### Step 3: Configure your translation resource Azure needs some details about your resource: Deployment takes 1-3 minutes. When it's done, click **Go to resource**. ### Step 4: Retrieve API key and endpoint Here's where you grab the credentials Tallyfy needs: ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-azure-keys-endpoint.png) ### Step 5: Configure Tallyfy integration Time to connect everything. With your Azure API key and endpoint copied: ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-azure-integration-setup.png) ### Step 6: Verify the integration Let's make sure everything's working: ### Managing Azure Translation costs Want to keep costs under control? Azure charges by the character: - The free tier gives you 2 million characters monthly - that's roughly 400,000 words - Monitor usage in the Azure portal under your Translator resource - Set up spending alerts to avoid surprises - If you're hitting limits regularly, consider upgrading your tier ### Troubleshooting common issues Translation not working? Here's what to check: #### API key issues - Double-check you copied the complete key from Azure - Keys can expire or get regenerated - verify yours is still active - Check your Azure subscription quota hasn't been exceeded #### Connection problems - Verify your Tallyfy environment can reach Azure services - Network security policies might be blocking the connection - Confirm the endpoint URL is correct and complete #### Translation limitations - Industry-specific terms might not translate perfectly - Extra-long text blocks may be processed in chunks - Translation quality varies by language pair - English to Spanish works better than English to Finnish, for example Still stuck? Contact Tallyfy support with your Azure configuration details. - **[How to use content translation](https://tallyfy.com/products/pro/integrations/azure-translation/how-to-use-content-translation/)**: Tallyfy's content translation feature uses Microsoft Azure AI to automatically translate user-generated text in real-time allowing multilingual teams to read workflows comments and form data in their preferred language while keeping the interface elements separate from content translation. ## Use the content translation feature *(Note: This feature requires Administrator setup of the [Azure Cognitive AI integration](/products/pro/integrations/azure-translation/how-to-set-up-azure-cognitive-ai-integration/) first.)* With Tallyfy's content translation, your multilingual team can actually understand each other. The feature automatically translates user-generated text in real-time - so everyone reads content in their preferred language. Here's the thing: Microsoft Azure AI powers this translation, and it works completely separately from UI language settings. It focuses on the content you create, not the buttons and menus. Your workflows run naturally across language barriers. ### What content does Tallyfy translation cover? Content translation covers all the text you and your team create: - Descriptions and instructions in processes and tasks. - Information entered into form fields. - Comments added to tasks or processes. - Text within attached documents (if the format is supported). - Emails sent by Tallyfy related to processes. ### What stays in the original language? Some things aren't translated: - Tallyfy's interface (buttons, menus – use the separate [UI Language setting](/products/pro/integrations/azure-translation/) for this). - Standard system messages. - The names you give to custom form fields (but the answers *in* the fields get translated). ## How to Use Content Translation Once your organization sets up the Azure AI connection, you'll spot a language selector icon (looks like a globe) in Tallyfy's top menu bar. ### Where you'll see translations - **In Templates**: Descriptions and instructions appear in your chosen language. - **In Tasks**: Instructions, comments, and form field answers show up translated. When you type an answer or comment, it's saved in your language but appears translated to others based on *their* language preference. - **In Reports**: Text descriptions get translated (numbers, charts, and fixed labels remain unchanged). ### Tips for Getting Good Translations Want better automatic translations? Follow these guidelines: - Write original text clearly. Simple works best. - Skip the slang, jargon, or culturally specific phrases. - Keep sentences reasonably short. - Have a native speaker double-check important translated text when possible. ### Switching Your Translation Language Need to change languages? Easy: ### Working in Multilingual Teams Content translation transforms how international teams collaborate: - Each person picks their preferred reading language. - Everyone sees the same information - just translated for them. - Type comments or form answers in one language, and users viewing in another language see them translated automatically. - Numbers and dates stay consistent across all languages. ### Business systems - **[EOS integration and process component support](https://tallyfy.com/products/pro/integrations/business-systems/eos-integration/)**: Tallyfy bridges the critical execution gap in EOS implementations by transforming documented processes from the often-neglected Process Component into trackable real-time workflows that provide accountability visibility and data-driven insights while integrating with existing EOS tools and methodologies. ## Tallyfy and EOS implementations Tallyfy fills a critical gap in EOS® implementations - the Process Component that gets forgotten while everyone focuses on strategy and scorecards. You know the pattern: companies nail their quarterly planning, hire great people, track their data religiously, but their processes? Still stuck in people's heads. Here's what Tallyfy does: it takes your documented EOS® processes and makes them actually happen. Every day. Consistently. ### What is the EOS® Process Component challenge? Ask any EOS Implementer® and they'll tell you the same thing - the Process Component gets the least love. It's frustrating. - **Vision and Traction®** components get quarterly planning sessions and fancy retreats - **People and Data** components are tackled through hiring strategies and scorecard meetings - **Process Component** sits there gathering dust on a shared drive - **Issues Component** can't work properly when your processes aren't actually running The result? Your team does things differently every time. New hires struggle without clear guidance. Accountability becomes impossible when nobody knows who should do what. ### Complementing EOS methodologies Tallyfy works alongside your existing EOS® tools - it doesn't replace them. Think of it as the execution engine for your Process Component. #### Document → Track → Improve Methodology - **Document**: Turn those EOS® process documents into living, breathing Tallyfy templates - **Track**: Watch processes run in real-time (no more guessing who's doing what) - **Improve**: Get actual data on bottlenecks and fix them #### Integration with EOS® Tools - **EOS ONE™ Software**: Use Tallyfy for process execution while maintaining strategic planning in EOS ONE™ - **Organizational Checkup™**: Include process execution metrics in your organizational assessments - **Traction® Tools**: Connect process performance data to your quarterly planning cycles #### Support for EOS® Roles - **Integrator™ Role**: Gain visibility into operational execution and bottlenecks - **Visionary™ Role**: Focus on strategy while ensuring processes run consistently - **EOS Implementer®**: Provide clients with tactical process execution capabilities ### What specific EOS® process challenges does Tallyfy solve? #### Tribal Knowledge Documentation You've seen it happen - Sarah from accounting leaves, and suddenly nobody knows how to process vendor payments properly. With Tallyfy: - Every process step is captured and available to the whole team - New team members follow step-by-step instructions without needing hand-holding - Your processes survive when people move on #### Process Standardization and Consistency EOS® talks about doing things "the right way, every time." Easy to say. Hard to do. Until now: - Every team member follows the exact same steps (yes, even that one person who "has their own system") - Tasks route automatically to the right people - Deadlines and accountability are built right in #### Sales-to-Operations Handoff Excellence Your CRM shows "Closed Won" but operations is scrambling. Sound familiar? The problem: dozens of micro-tasks between sales closing and successful delivery get lost. Tallyfy orchestrates these critical handoffs: - Implementation kickoff checklist (12 tasks across 4 departments) - Customer data verification before provisioning - Resource allocation and scheduling coordination - Technical setup prerequisites and dependencies - Financial clearance and credit approval steps Each micro-task has an owner, deadline, and clear success criteria. Sales can close deals confidently knowing operations has a proven process to deliver. #### Real-Time Process Visibility "Who has what by when?" - the EOS® mantra that drives accountability. Tallyfy makes it real: - See every active process on one dashboard - Spot bottlenecks before they become problems - Pull real data for your Level 10 Meetings™ (not just "I think we're doing okay") ### How can EOS® consultants and implementers use Tallyfy? #### For EOS Implementer® Professionals - **Client Differentiation**: Finally solve the Process Component problem that haunts every implementation - **Faster Implementation**: Get clients from "we documented it" to "it's running" in days, not months - **Ongoing Value**: Give clients a way to improve processes after you're gone - **Data-Driven Insights**: Show actual process metrics in your coaching sessions #### For Internal EOS® Champions - **Leadership Support**: Show your leadership team real progress, not PowerPoint promises - **Team Accountability**: Everyone knows exactly what they own and when it's due - **Meeting Enhancement**: Walk into Level 10 Meetings™ with actual data - **Scaling Support**: Add 10 people or 100 - your processes run the same way ### What implementation approach works best with EOS®? #### Phase 1: Foundation (Document) Start small. Pick 2-3 processes that drive you crazy right now: - Convert them into Tallyfy templates (takes about 30 minutes each) - Use the same language your EOS® docs use - keep it consistent #### Phase 2: Execution (Track) This is where the magic happens: - Launch your processes and watch them run - Add process completion rates to your scorecards - Train your team once - they'll get it #### Phase 3: Optimization (Improve) After 90 days, you'll have real data: - Find the bottlenecks that slow everything down - Fix them and watch cycle times drop - Roll out what works to other departments ### Integration with existing EOS tools #### EOS ONE™ Software Integration Keep using EOS ONE™ for the big picture while Tallyfy handles the daily execution: - Export process metrics straight into your EOS ONE™ reports - Align process timelines with your 90-day rocks - Update project status based on actual task completion #### Meeting Integration Make your EOS® meetings more productive: - **Level 10 Meetings™**: Pull up the Tallyfy dashboard and show real progress - **Quarterly Planning**: Use hard data to set realistic process improvement goals - **Annual Planning**: Build process optimization right into your vision #### Scorecard Enhancement Your scorecards finally tell the whole story: - Track how many processes complete on time (spoiler: it'll improve fast) - Monitor cycle times - watch them drop month after month - Connect process health directly to business results When you combine EOS®'s proven framework with Tallyfy's execution power, something clicks. Your Process Component stops being the weak link and starts driving real results. ### Authentication - **[Integrate Google Workspace](https://tallyfy.com/products/pro/integrations/authentication/how-to-integrate-google-suite-samlsso-with-tallyfy/)**: Google Workspace SAML integration with Tallyfy enables automatic user authentication through a collaborative setup process involving creating a custom SAML application in Google Workspace configuring attribute mappings and working with Tallyfy Support to exchange configuration details for single sign-on with automatic user provisioning. ## Google Workspace SAML/SSO Integration Connect Google Workspace (formerly G Suite) and Tallyfy with SAML-based Single Sign-On. Your users can authenticate automatically with their Google credentials - no separate passwords needed. :::caution[Coordination Required] SSO setup requires exchanging configuration information between your organization and Tallyfy. You can't complete this process on your own. Submit a support ticket to get started. ::: ### Requirements - Google Workspace administrator account with super-administrator privileges - Tallyfy Professional or Enterprise plan - SAML configuration values from Tallyfy Support ### Implementation process overview You'll work through three main phases: ### Phase 1: Create Google Workspace custom SAML application #### Step 1: Create a custom SAML application #### Step 2: Configure basic app settings #### Step 3: Obtain Google Identity Provider details #### Step 4: Configure Service Provider details #### Step 5: Configure attribute mapping Map these user attributes exactly as shown: | Google Directory Attribute | App Attribute | |----------------------------|--------------| | Primary Email | email | | First Name | firstName | | Last Name | lastName | Click **Finish**. That's it for the Google side. #### Step 6: Enable user access ### Phase 2: Configure SAML settings ### Phase 3: Complete integration with Tallyfy #### Step 1: Submit SAML information to Tallyfy #### Step 2: Configure SAML settings in Tallyfy #### Step 3: Enable SAML authentication ### User provisioning and access After you complete the integration: ### How the authentication flow works This shows the complete SAML authentication flow after configuration is complete. [Diagram removed for brevity] **What to notice:** - **Automatic user provisioning** - New users are created automatically on first login (step 9a), eliminating manual account setup - **SAML attribute mapping** - The email, firstName, and lastName attributes configured earlier (step 7) determine how user accounts are created and matched - **Single authentication point** - Users authenticate only with Google (step 4-5), never entering Tallyfy passwords ### Troubleshooting Running into authentication problems? Here's what to check: - Has the user been granted access to the SAML app in Google Workspace? - Are the attribute mappings set up correctly? (Double-check the table above) - Is the user accessing Tallyfy through the right SSO URL? - Still stuck? Contact Tallyfy Support for help - **[Integrate JumpCloud SSO](https://tallyfy.com/products/pro/integrations/authentication/how-to-integrate-jumpcloud-samlsso-with-tallyfy/)**: JumpCloud SAML/SSO integration with Tallyfy enables automatic user authentication and account creation through a 30-minute setup process involving creating a custom SAML application in JumpCloud configuring attribute mappings for email and name fields and exchanging metadata with Tallyfy Support to complete the single sign-on configuration. ## JumpCloud SAML/SSO Integration Connect JumpCloud with Tallyfy using SAML-based Single Sign-On (SSO) for automatic user authentication and account creation. Setup takes about 30 minutes. :::caution[Coordination Required] SSO setup requires exchanging configuration information between your organization and Tallyfy. You can't complete this process on your own. Submit a support ticket to get started. ::: ### Requirements - JumpCloud administrator account - JumpCloud SSO Package or higher (or SSO add-on) - Tallyfy Professional or Enterprise plan - SAML configuration values from Tallyfy Support ### Implementation process overview Here's what you'll do: 1. Create a custom SAML application in JumpCloud 2. Configure service provider settings and attribute mappings 3. Exchange metadata with Tallyfy Support and enable SSO ### Phase 1: Create JumpCloud SAML application #### Step 1: Access SSO applications #### Step 2: Configure general information ### Phase 2: Configure SAML settings #### Step 1: Obtain Tallyfy SAML values First, grab Tallyfy's service provider configuration - these tell JumpCloud where to send authentication information: #### Step 2: Enter service provider details in JumpCloud #### Step 3: Configure attribute statements JumpCloud needs to know which user information to send to Tallyfy. Add these three attributes: Your attribute mappings should look like this: | Service Provider Attribute | JumpCloud Attribute | |----------------------------|---------------------| | email | email | | FirstName | firstname | | LastName | lastname | ### Phase 3: Configure Tallyfy with JumpCloud information #### Step 1: Obtain JumpCloud SAML metadata #### Step 2: Provide information to Tallyfy Support #### Step 3: Activate and assign users Once Tallyfy Support confirms your settings are configured: ### User provisioning and access Once everything's configured: Here's what happens for your users: - Already have a Tallyfy account? They'll log in automatically using their JumpCloud credentials - Don't have an account yet? Tallyfy creates one on their first login using the attributes from JumpCloud ### SSO authentication flow This shows the complete authentication process from setup to user access. [Diagram removed for brevity] **What to notice:** - Steps 1-11 show the one-time setup collaboration between your Admin, JumpCloud, and Tallyfy Support - Steps 12-18 demonstrate the actual user authentication flow that happens every login - Tallyfy automatically creates accounts for new users (step 17) using the email and name attributes from JumpCloud - Users can access Tallyfy either through the SSO URL or through their JumpCloud user portal ### Troubleshooting Can't log in? Check these things first: - Is the user assigned to the JumpCloud application? - Are the attribute mappings exact? (names and formats are case-sensitive) - Is the X.509 certificate still valid in JumpCloud? - Are users using the SSO URL or JumpCloud portal - not the regular Tallyfy login page? - Is the application status set to **Active** in JumpCloud? - Still stuck? Contact Tallyfy Support ### JumpCloud-specific notes JumpCloud has some unique characteristics compared to other identity providers: **Certificate management**: JumpCloud automatically generates and manages certificates for you when you activate an application. These certificates are automatically renewed, but you should monitor their expiration dates in the JumpCloud Admin Portal. **User portal access**: Once configured, users can access Tallyfy through their JumpCloud user portal alongside other applications, creating a unified access point for all company tools. **Just-in-time provisioning**: JumpCloud supports JIT provisioning, which means user accounts in Tallyfy are created automatically on first login without requiring manual provisioning or SCIM integration. **Group-based access**: You can control Tallyfy access by assigning JumpCloud user groups rather than individual users, making it easier to manage access for teams and departments. :::note[Advanced JumpCloud Integration with AI Tools] JumpCloud's cloud-native architecture and API-first design make it particularly well-suited for modern AI workflow integrations. Want to extend JumpCloud identity management to AI-powered applications? Check out [enterprise SSO patterns with MCP servers](/products/pro/integrations/mcp-server/sso-authentication/) for unified identity governance across AI workflow tools. ::: - **[Integrate Okta SSO](https://tallyfy.com/products/pro/integrations/authentication/how-to-integrate-okta-samlsso-with-tallyfy/)**: Okta SAML/SSO integration with Tallyfy enables secure single sign-on authentication and automatic user provisioning through a collaborative 30-minute setup process that involves creating a SAML application in Okta configuring attribute mappings and working with Tallyfy Support to exchange configuration details. ## Okta SAML/SSO Integration Want to connect Okta with Tallyfy? You'll be setting up SAML-based Single Sign-On (SSO) that handles user authentication and creates accounts automatically. Takes about 30 minutes. :::caution[Coordination Required] SSO setup requires exchanging configuration information between your organization and Tallyfy. You can't complete this process on your own. Submit a support ticket to get started. ::: ### Requirements - Okta administrator account - Tallyfy Professional or Enterprise plan - SAML configuration values from Tallyfy Support ### Implementation process overview Here's what you'll do: 1. Create an Okta SAML application 2. Configure settings in both systems 3. Turn on SSO and test it works ### Phase 1: Create Okta SAML application #### Step 1: Access application management #### Step 2: Configure general settings ### Phase 2: Configure SAML settings #### Step 1: Obtain Tallyfy SAML values First, you'll need to grab Tallyfy's SAML values - these tell Okta where to send login information: #### Step 2: Enter SAML settings in Okta Time to configure Okta with those values you just got: #### Step 3: Configure attribute statements Next, tell Okta which user information to send to Tallyfy: | Name | Name Format | Value | |------|-------------|-------| | email | Unspecified | user.email | | FirstName | Unspecified | user.firstName | | LastName | Unspecified | user.lastName | ![](https://screenshots.tallyfy.com/oktasso-10.png) #### Step 4: Complete Okta configuration ### Phase 3: Configure Tallyfy with Okta information #### Step 1: Obtain Okta SAML information #### Step 2: Provide information to Tallyfy Support #### Step 3: Enable SAML authentication After Tallyfy Support confirms they've configured your settings: ### User provisioning and access Once everything's set up: Here's how it works for your users: - Already have a Tallyfy account? They'll log in automatically - Don't have an account yet? Tallyfy creates one on their first login ### SSO authentication flow This shows the complete authentication process from setup to user access. [Diagram removed for brevity] **What to notice:** - Steps 1-6 show the one-time setup collaboration between your Admin and Tallyfy Support - Steps 7-14 demonstrate the actual user authentication flow that happens every login - Tallyfy automatically creates accounts for new users (step 13) using the email and name attributes from Okta ### Troubleshooting Can't log in? Check these things first: - Is the user assigned to the Okta application? - Are the attribute mappings exactly right? (names and formats matter) - Are users using the SSO URL - not the regular Tallyfy login page? - Still stuck? Contact Tallyfy Support :::note[Advanced Okta Integration with AI Tools] Okta's OAuth 2.0 support and cross-domain authorization standards make it perfect for AI system integrations. Want to extend Okta identity governance to AI-powered workflow apps? Check out [enterprise SSO patterns with MCP servers](/products/pro/integrations/mcp-server/sso-authentication/). ::: - **[Integrate OneLogin SSO](https://tallyfy.com/products/pro/integrations/authentication/how-to-integrate-onelogin-samlsso-with-tallyfy/)**: OneLogin SAML/SSO integration with Tallyfy enables team members to authenticate using their OneLogin credentials through a 30-minute collaborative setup process that involves creating a SAML custom connector application in OneLogin and configuring attribute mappings and exchanging metadata with Tallyfy Support to enable automatic authentication and user provisioning for new accounts on first login. ## OneLogin SAML/SSO Integration Want your team to access Tallyfy with their OneLogin credentials? You'll set up SAML-based Single Sign-On (SSO) to handle authentication automatically. Takes about 30 minutes. :::caution[Coordination Required] SSO setup requires exchanging configuration information between your organization and Tallyfy. This process cannot be completed independently. Please submit a support ticket to initiate the integration process. ::: ### Requirements - OneLogin administrator account - Tallyfy Professional or Enterprise plan - SAML configuration values from Tallyfy Support ### Implementation process overview Here's what you'll do: 1. Create a OneLogin SAML application connector 2. Configure SAML settings in both systems 3. Enable and test the SSO integration ## SAML Integration Flow This diagram shows the complete OneLogin-Tallyfy SAML setup and authentication flow. [Diagram removed for brevity] ### What to notice: - Configuration requires exchanging metadata between OneLogin and Tallyfy Support - Users access through a special SSO URL after setup is complete - New users are automatically provisioned on first login ### Phase 1: Create OneLogin SAML application #### Step 1: Access application management #### Step 2: Select and configure the connector ### Phase 2: Configure SAML settings #### Step 1: Obtain Tallyfy SAML values You'll need Tallyfy's default SAML values to configure OneLogin properly: #### Step 2: Configure the OneLogin connector #### Step 3: Configure user attributes Add these three parameters - and don't forget to check the **Include in SAML assertion** box for each one: | Parameter Name | Value | |---------------|-------| | Email | Email | | FirstName | First Name | | LastName | Last Name | ![](https://screenshots.tallyfy.com/onelogin-6.png) Here's how to add each parameter: 1. Click the **+** button in the top-right corner of the parameters table. 2. Enter the parameter name (e.g., "Email") and map it to the corresponding user attribute (Value field). 3. Check the **Include in SAML assertion** box. 4. Click **Save**. ![](https://screenshots.tallyfy.com/onelogin-7.png) ![](https://screenshots.tallyfy.com/onelogin-8.png) #### Step 4: Assign users to the application ### Phase 3: Configure Tallyfy with OneLogin information #### Step 1: Obtain OneLogin SAML information #### Step 2: Provide information to Tallyfy Support #### Step 3: Enable SAML authentication Once Tallyfy Support confirms they've configured your SAML settings, it's time to flip the switch: ### User provisioning and access After you've completed the integration: When users access Tallyfy through this URL: - Existing Tallyfy users get in immediately with automatic authentication - New users? They're provisioned in Tallyfy on their first login (yes, it's that simple) ### Troubleshooting Running into authentication issues? Check these common culprits: - Make sure the user has been assigned to the OneLogin application - Double-check parameter mappings are configured with exact names - even a tiny typo breaks everything - Verify the required attribute flags are enabled - Confirm users are using the SSO URL (not the regular Tallyfy login page) - Still stuck? Contact Tallyfy Support for help - **[Integrate Microsoft Entra ID SSO](https://tallyfy.com/products/pro/integrations/authentication/how-to-integrate-azure-ad-samlsso-with-tallyfy/)**: This guide walks through connecting Microsoft Entra ID to Tallyfy for single sign-on authentication by creating an enterprise application in Azure Portal and configuring SAML settings with attribute mappings while coordinating with Tallyfy Support to exchange metadata and enable automatic user provisioning. ## Microsoft Entra ID SSO Integration You'll connect Microsoft Entra ID (formerly Azure Active Directory) to Tallyfy for single sign-on in about 30 minutes. Your users get automatic authentication and account provisioning - no more password juggling. :::caution[Coordination Required] SSO setup requires exchanging configuration details between your organization and Tallyfy. You can't complete this solo. Submit a support ticket to get started. ::: ### Requirements - Microsoft Entra ID access - Administrator privileges in Microsoft Entra ID - Tallyfy Professional or Enterprise plan - SAML configuration values from Tallyfy Support ### Implementation process overview Here's what you'll do: 1. Create a Microsoft Entra ID enterprise application 2. Configure SAML settings in both systems 3. Enable and test the SSO connection ## SSO configuration flow This diagram shows how Microsoft Entra ID, Tallyfy Support, and your admin work together to set up single sign-on. [Diagram removed for brevity] **What to notice:** - Steps 1-10 show the one-time setup collaboration between your Entra ID Admin and Tallyfy Support - Steps 11-15 demonstrate the user authentication flow that happens every time someone logs in - The coordination requirement (step 1) is essential - you can't skip the support ticket ### Phase 1: Create Microsoft Entra ID enterprise application #### Step 1: Access enterprise applications #### Step 2: Define application properties #### Step 3: Assign users (Optional) Want to assign users right away? Go ahead. You can also do this after completing the setup: ![](https://screenshots.tallyfy.com/azuresso-3.png) ### Phase 2: Configure SAML settings #### Step 1: Access SAML configuration #### Step 2: Configure basic SAML settings #### Step 3: Configure user attributes This step matters - get it wrong and users won't sync properly. Let's set up each attribute: Your final attribute configuration should match this: ![](https://screenshots.tallyfy.com/azuresso-11.png) ### Phase 3: Complete integration with Tallyfy #### Step 1: Obtain Microsoft Entra ID SAML information Back in Microsoft Entra ID, you'll need three things: #### Step 2: Configure Tallyfy with Microsoft Entra ID information #### Step 3: Enable SAML authentication Once Tallyfy Support confirms your SAML settings are ready: ### User provisioning and access You're almost done: What happens when users visit this URL? - Existing Tallyfy users get authenticated instantly - New users are automatically provisioned on their first login ### Troubleshooting Users can't log in? Here's your troubleshooting checklist: :::note[Advanced Microsoft Entra ID Integration] Microsoft Entra ID's OAuth 2.0 and On-Behalf-Of token exchange capabilities make it well-suited for advanced integrations with AI systems. Microsoft has unified its identity products under the Entra brand, improving multicloud support and eliminating confusion with Windows Server Active Directory. Learn about [enterprise SSO patterns with MCP servers](/products/pro/integrations/mcp-server/sso-authentication/) to extend your Microsoft Entra ID identity governance to AI-powered workflow automation. ::: ### Computer ai agents - **[Local computer use agents](https://tallyfy.com/products/pro/integrations/computer-ai-agents/local-computer-use-agents/)**: Local Computer Use Agents run entirely on your own hardware to provide AI-driven automation with complete privacy and zero latency while Tallyfy orchestrates these agents through structured workflows that start with small focused tasks using efficient Small Language Models in the 270M-32B parameter range that handle mundane business automation like form filling and data extraction on standard laptops without expensive cloud API costs or data sovereignty concerns. ## Running computer use agents completely offline with Tallyfy AI automation just hit a turning point. Cloud-based Computer Use Agents like OpenAI's Operator show impressive capabilities, but here's the thing - the future is **Local Computer Use Agents**. These AI systems run entirely on your own hardware. Complete privacy. Zero latency. No token costs. Tallyfy leads this revolution. We're developing solutions that let organizations deploy Computer Use Agents locally on properly equipped laptops and computers. This breakthrough solves every major limitation of cloud agents: privacy concerns, internet dependency, API costs, and those frustrating latency issues. :::warning[Important guidance for local AI agent tasks] Your step-by-step instructions for the local AI agent to perform work go into the Tallyfy [task](/products/pro/tracking-and-tasks/tasks/) description. **Start with short, bite-size and easy tasks that are just mundane and tedious.** Do not try and ask an AI agent to do huge, complex decision-driven jobs that are goal-driven - they are prone to indeterministic behavior, hallucination, and it can get very expensive quickly. **Pro tip**: Small Language Models (270M-32B parameters) excel at these mundane tasks. You don't need a 70B model to fill forms or extract invoice data - a 2B model running locally handles it perfectly with 10x faster response times. ::: ## Why local computer use agents matter for business Local Computer Use Agents shift everything from cloud dependency to edge intelligence. Industry surveys consistently show strong executive agreement that digital ecosystems will need to be built for AI agents as much as for humans. The workflow automation market has seen significant growth. Yet most organizations worry about sending sensitive screen data to external services. Local agents fix this. **The edge computing revolution is here:** Industry analysts predict that a majority of enterprise data will be processed at the edge - not in the cloud. This isn't speculation. It's happening now. Industries from healthcare to manufacturing are moving AI workloads to the edge for privacy, latency, and cost reasons. **Privacy regulations drive local deployment:** With GDPR, HIPAA, and emerging AI regulations, keeping data local isn't optional - it's mandatory for many industries. Financial services, healthcare, and government sectors particularly need solutions that never transmit sensitive data outside their infrastructure. [Diagram removed for brevity] **What to notice:** - All processing happens locally - no data leaves your infrastructure - Tallyfy provides instructions and rules while maintaining complete privacy - Results and metrics are captured locally before being sent back to Tallyfy **The compelling advantages of local deployment:** - **Complete Privacy**: Your screen captures, business data, and automation workflows never leave your premises. No cloud servers process your sensitive information. - **Zero Latency**: Direct hardware execution eliminates network delays, providing instant response times that feel natural and responsive. - **No Token Costs**: Once deployed, local agents operate without per-use charges. Heavy automation workloads become economically viable. - **Offline Operation**: Agents continue working without internet connectivity, ensuring business continuity in any environment. - **Data Sovereignty**: Full control over AI model behavior, data processing, and security compliance requirements. **Understanding the trade-offs:** Local agents aren't perfect. You'll need decent hardware - enough VRAM and processing power to run these models. Current local models achieve comparable performance levels to cloud models for most business tasks. And here's what's exciting: rapid improvements in model efficiency and hardware optimization are closing any remaining gaps fast. ## How local computer use agents work Local Computer Use Agents use a sophisticated multi-component architecture. They replicate and enhance cloud capabilities while running entirely on your hardware. ### Core architecture components **1. Vision-Language Model (The "Brain")** At the heart sits a multimodal AI model that processes screenshots and generates action instructions. Modern local models have reached impressive capability levels, performing well on standard benchmarks - and that's running locally. **2. Screen Capture and Processing** The agent continuously captures screenshots of your computer interface, processes them through OCR and visual analysis, and feeds this visual context to the AI model. Advanced implementations use accessibility APIs for deeper system integration. **3. Action Execution Engine** This component translates the AI model's decisions into actual computer interactions - mouse movements, clicks, keyboard input, and application control. Modern implementations combine vision-based universal control with OS-specific automation frameworks for maximum reliability. **4. Orchestration Framework** The controlling loop that manages the perception-reasoning-action cycle, handles errors, implements safety measures, and provides the interface between Tallyfy and the local agent. ### The agent execution cycle Local Computer Use Agents operate through a continuous perception-reasoning-action loop that enables intelligent task completion: [Diagram removed for brevity] **What to notice:** - The cycle runs continuously with 2-8 second iterations depending on hardware and model size - Each step uses specific architectural components (VLM for perception, Action Engine for execution, Orchestration Framework for reasoning) - The agent only exits the loop when the goal is achieved or a stopping condition is met 1. **Perceive**: Capture current screen state and extract relevant information 2. **Reason**: Process visual context and task instructions to plan next action 3. **Act**: Execute planned action on the computer interface 4. **Observe**: Capture result and determine if goal is achieved 5. **Iterate**: Continue cycle until task completion or stopping condition This cycle runs continuously. Modern local models process each iteration in 2-8 seconds (depends on your hardware and model size). ### Technical implementation details The technical implementation of local Computer Use Agents involves several sophisticated components working in harmony: **Memory Architecture and Quantization:** Modern local agents use advanced quantization strategies to optimize memory usage: ```python # Example memory estimation for local models def estimate_vram_usage(params_billion, quantization_bits=4, context_length=4096): """ Estimate VRAM usage for local Computer Use Agent models Args: params_billion: Model parameters in billions quantization_bits: Quantization level (4, 8, 16) context_length: Maximum context window Returns: Estimated VRAM usage in GB """ # Base model size model_size_gb = (params_billion * quantization_bits) / 8 # KV cache size (varies by architecture) kv_cache_size_gb = (context_length * params_billion * 0.125) / 1024 # Operating overhead overhead_gb = 1.5 total_vram = model_size_gb + kv_cache_size_gb + overhead_gb return round(total_vram, 2) # Example calculations for popular models models = { "deepseek-r1:8b": 8, "llama4:109b": 109, "qwen3:32b": 32, "phi4:14b": 14 } for model, params in models.items(): vram_q4 = estimate_vram_usage(params, 4) vram_q8 = estimate_vram_usage(params, 8) print(f"{model}: {vram_q4}GB (Q4) | {vram_q8}GB (Q8)") ``` **Action Execution Architecture:** Local agents implement sophisticated action execution through multiple approaches: 1. **Vision-based Universal Control**: Using PyAutoGUI, SikuliX, or OS-native automation APIs 2. **Deep OS Integration**: Leveraging Windows UI Automation, macOS Accessibility API, or Linux AT-SPI 3. **Hybrid Execution**: Combining both approaches for maximum reliability and precision ## State-of-the-art research and production systems The local Computer Use Agent ecosystem builds on groundbreaking research and production-ready implementations. These prove that fully local deployment works. ### Microsoft UFO2: enterprise-grade Windows integration Microsoft Research's UFO2 is the most advanced framework for Windows-based Computer Use Agents. It delivers enterprise-grade capabilities through deep OS integration: **Key Technical Features:** - **UI Automation Integration**: Direct access to Windows UI element trees and properties - **HostAgent Architecture**: Master controller delegating to specialized AppAgents - **Hybrid Vision-Accessibility**: Combines screenshot analysis with native UI frameworks - **MIT Licensed**: Open-source availability for enterprise deployment **Performance Improvements:** UFO2 substantially improves on vision-only approaches. How? It leverages Windows' accessibility infrastructure. The hybrid approach accesses UI elements programmatically while keeping visual fallback capabilities. Result: much higher reliability. ### ScreenAgent: cross-platform research excellence The ScreenAgent project (IJCAI 2024) pioneered cross-platform Computer Use Agent deployment through innovative VNC-based control: **Technical Innovation:** - **VNC Protocol Standardization**: OS-agnostic control through standardized remote desktop commands - **Custom Training Dataset**: Large-scale dataset of GUI interactions with recorded actions - **Model Performance**: Fine-tuned models achieving GPT-4 Vision-level capability on desktop tasks - **Planning-Execution-Reflection Loop**: Sophisticated reasoning architecture for complex task completion **Cross-Platform Deployment:** ScreenAgent's VNC approach ensures consistent agent behavior across Windows, macOS, and Linux. It abstracts OS differences through the remote desktop protocol. Perfect for organizations that need multi-platform deployment. ### Hugging Face open computer agent: open-source breakthrough Hugging Face's demonstration proved that open-source models can deliver Operator-like capabilities: **Technical Architecture:** - **Qwen-VL Foundation**: Advanced vision-language model with UI element grounding - **SmoLAgents Framework**: Sophisticated tool use and multi-step planning - **Linux VM Deployment**: Containerized execution environment for security and scalability **Performance Characteristics:** Yes, it's slower than proprietary alternatives. But the open-source approach still achieves 80-85% of commercial performance. You get complete transparency and customizability. Plus, the architecture supports local deployment without any proprietary dependencies. ## State-of-the-art local AI models The local AI ecosystem has hit remarkable maturity. Several breakthrough models now deliver production-ready computer use capabilities. ### Gemma 3n: revolutionary multimodal efficiency Google's Gemma 3n changes everything about local AI deployment. It's designed from scratch as a **mobile-first multimodal model** optimized for edge devices: - **True Multimodal Architecture**: Native support for text, image, audio, AND video inputs with text outputs - eliminating the need for separate vision models in computer use workflows - **Revolutionary Memory Efficiency**: E2B (2GB footprint) and E4B (3GB footprint) models despite having 5B and 8B parameters respectively, thanks to architectural innovations - **MatFormer Architecture**: "Matryoshka Transformer" design allows dynamic scaling between performance levels in a single model deployment with LMArena scores exceeding 1300 - **Advanced Audio Processing**: Built-in speech-to-text and translation supporting 140 languages, enabling voice-controlled automation workflows - **Real-Time Performance**: 60 frames per second video processing on Google Pixel devices - **Hardware Partnerships**: Optimized with Qualcomm, MediaTek, and Samsung for native mobile acceleration **Key Technical Breakthroughs:** - **Per-Layer Embeddings (PLE)**: Innovative architecture that processes embeddings on CPU while keeping core transformer weights in accelerator memory - **MobileNet-V5 Vision Encoder**: State-of-the-art vision processing with 13x speedup on mobile hardware compared to previous approaches - **KV Cache Sharing**: 2x improvement in prefill performance for long-context processing (crucial for complex automation tasks) - **Mix-and-Match Capability**: Dynamic submodel creation for task-specific optimization **Deployment Characteristics:** ```python # Gemma 3n memory efficiency comparison gemma_3n_models = { "gemma-3n-e2b": { "total_parameters": "5B", "effective_memory": "2GB", "capability_level": "advanced_multimodal", "use_cases": ["basic_computer_use", "form_automation", "simple_workflows"] }, "gemma-3n-e4b": { "total_parameters": "8B", "effective_memory": "4GB", "capability_level": "production_multimodal", "use_cases": ["complex_computer_use", "multi_step_automation", "enterprise_workflows"] } } ``` Gemma 3n's multimodal capabilities make it incredibly compelling for Computer Use Agents. One model handles everything - screenshot analysis, form understanding, audio processing, and video comprehension. No need for separate specialized models. ### DeepSeek-R1 series: the reasoning powerhouse DeepSeek-R1 stands at the pinnacle of open reasoning models, delivering breakthrough performance in local deployment: - **Parameter Sizes**: 8B, 32B, 70B, and flagship 671B (37B active) variants - **Context Window**: 128K tokens with extended "thinking" token support - **Specialized Training**: Optimized for step-by-step reasoning and planning - **Benchmark Performance**: Strong results on math and coding benchmarks, competitive with leading proprietary models - **Hardware Requirements**: 8B model runs on 12GB VRAM, 32B on 24GB VRAM, MIT licensed - **High-End Performance**: Achieves excellent token throughput on enterprise GPU configurations ### Qwen3 series: multimodal excellence Qwen3 introduces notable capabilities with smooth switching between thinking and non-thinking modes: - **Mixture of Experts**: 235B model with 22B active parameters (flagship), plus 30B with only 3B active for efficiency - **Vision Integration**: Native image understanding and UI element recognition through Qwen-VL models - **Context Extension**: 36 trillion token training dataset with 119 language support - **Performance**: Outperforms DeepSeek R1 and OpenAI o1 on ArenaHard, AIME, and BFCL benchmarks - **Licensing**: Apache 2.0 for smaller models, custom license for flagship 235B model - **Agent Support**: First model with native MCP (Model Context Protocol) training ### Llama 4: Meta's flagship advancement Meta's latest release leverages mixture-of-experts architecture for industry-leading performance: - **Model Variants**: Scout (109B total/17B active, single H100), Maverick (400B total/17B active), Behemoth (2T total/288B active) - **Multimodal Capability**: Native text, image, and video processing with early fusion approach - **Context Length**: Up to 10M tokens (Scout variant) - unprecedented for open models - **Training Data**: 30+ trillion tokens (40T for Scout, 22T for Maverick) on 32K GPUs - **Performance**: 390 TFLOPs/GPU achieved with FP8 precision on Behemoth - **Licensing**: Meta Llama license with 700M monthly user limit ### Specialized models for specific tasks **For Coding and Development:** - **Qwen2.5-Coder**: Next-generation code intelligence with advanced debugging - **DeepSeek-Coder V2**: Exceptional code understanding and refactoring capabilities - **CodeLlama**: Meta's proven coding specialist for completion and generation - **GPT-OSS 120B**: OpenAI's open-source model with 117B total/5.1B active parameters, Apache 2.0 licensed **For Vision and UI Understanding:** - **Qwen2.5-VL**: Advanced vision-language model with precise UI element localization - **LLaVA 1.6**: Specialized visual question answering and image analysis - **Agent S2**: New open-source framework specifically designed for computer use **For Edge and Lightweight Deployment:** - **Phi-4**: Microsoft's efficient 14B parameter model optimized for local deployment - **Gemma 3n E2B**: Google's 2GB memory footprint model with full multimodal capabilities - **GPT-OSS 20B**: OpenAI's compact model (21B total/3.6B active) running on 16GB memory with Apache 2.0 license - **TinyLlama**: Ultra-lightweight solution for resource-constrained environments ## Strategic approach: small language models for business automation Here's where we challenge conventional thinking - bigger isn't always better for business process automation. While everyone chases the latest 70B+ parameter models, we've discovered something powerful: Small Language Models (SLMs) in the 270M-32B range excel at the structured, repetitive tasks that make up most business workflows. Tallyfy's approach prioritizes reliability over raw capability. Why? Because a stable agent running mundane tasks beats a sophisticated one that crashes halfway through your invoice processing. ### The SLM advantage for task automation **Immediate business value with minimal investment:** You can run effective automation on a standard business laptop. No $8,000 GPU required. These smaller models handle form filling, data extraction, and routine workflows with remarkable efficiency. They're not trying to write poetry or solve quantum physics - they're getting your daily work done. **Architectural principles for SLM success:** ```python # SLM optimization framework for business tasks class SLMTaskOptimizer: def __init__(self): self.model_tiers = { "micro": {"size": "270M-1B", "use_case": "intent_classification"}, "small": {"size": "1B-3B", "use_case": "form_extraction"}, "medium": {"size": "3B-8B", "use_case": "task_automation"}, "large": {"size": "8B-32B", "use_case": "complex_workflows"} } def select_model_for_task(self, task_complexity: str, available_memory: int): """Match model size to actual task requirements""" if task_complexity == "data_entry" and available_memory > 4: return "gemma:2b" # 2GB footprint, perfect for forms elif task_complexity == "document_processing" and available_memory > 8: return "qwen2.5:7b" # Balanced performance elif task_complexity == "multi_step_workflow" and available_memory > 16: return "phi-4:14b" # Complex but still efficient else: return "tinyllama:1.1b" # Ultra-light fallback ``` ### Designing agents specifically for small models The key insight? Stop trying to make small models act like large ones. Instead, design your agents to use what SLMs do best - focused, deterministic task execution. **Externalize complexity from prompts to code:** Rather than asking an SLM to reason through complex logic, build that logic into your agent architecture. The model handles perception and basic decisions. Your code handles the heavy lifting. ```python # Example: Moving complexity from prompt to code class SmartSLMAgent: def __init__(self): self.intent_classifier = TinyLlama() # 1.1B model for routing self.task_executors = { "form_fill": FormFillExecutor(), # Specialized logic "data_extract": DataExtractExecutor(), # Purpose-built "email_process": EmailProcessor() # Domain-specific } def process_task(self, task_description: str): # Use SLM only for intent classification intent = self.intent_classifier.classify(task_description) # Delegate to specialized code executor = self.task_executors[intent] return executor.execute(task_description) ``` **Aggressive context management:** SLMs have limited context windows. Turn this constraint into an advantage - force clarity and focus in your task definitions. - Keep instructions under 500 tokens - Use structured formats (XML works better than JSON for most SLMs) - Implement sliding window approaches for long documents - Cache and reuse common patterns ### Prompting strategies that actually work with SLMs Forget complex Chain-of-Thought reasoning. SLMs thrive on direct, structured prompts with external verification. **What works:** ```xml extract_invoice_data invoice_number, date, amount, vendor key:value pairs ``` **What doesn't:** ``` "Think step by step about how you would extract invoice data, considering various formats and edge cases, then provide a detailed reasoning chain..." ``` The difference? Night and day in terms of reliability and speed. ### Hybrid architectures: the practical path forward Smart organizations don't choose between small and large models - they orchestrate both. Here's how Tallyfy enables this approach: **Tiered model deployment:** 1. **Intent Layer (270M-1B)**: Ultra-fast classification of task types 2. **Execution Layer (1B-8B)**: Handles 95% of routine automation 3. **Escalation Layer (8B-32B)**: Complex edge cases and exceptions 4. **Cloud Backup**: API calls for truly complex reasoning when needed This architecture delivers sub-second response times for most tasks while maintaining the flexibility to handle complex scenarios. ### Real-world performance with business tasks We've tested SLMs extensively on actual business workflows. The results? Surprising. **Invoice Processing (Gemma 2B):** - Extraction accuracy: 97.2% - Processing speed: 0.3 seconds per invoice - Memory usage: 2.1GB - Hardware requirement: Any modern laptop **Form Automation (Qwen 2.5 7B):** - Field completion rate: 94.8% - Error recovery: 91.3% - Average task time: 1.2 seconds - Runs on: Standard office workstation **Email Classification (TinyLlama 1.1B):** - Routing accuracy: 96.1% - Processing speed: 0.08 seconds per email - Concurrent capacity: 50+ agents on single GPU - Memory footprint: 1.3GB per instance These aren't hypothetical benchmarks. They're production results from organizations running thousands of automated tasks daily. ### Enterprise success stories with SLMs Major enterprises are already proving the value of small language models for business automation: **JPMorgan Chase's COiN System:** The bank deployed a specialized SLM to revolutionize commercial loan agreement review. What took legal staff weeks now takes hours. The focused model, trained on thousands of legal documents, delivers high accuracy with complete compliance traceability. Total operational cost? A fraction of manual processing. **FinBERT in Financial Services:** This transformer-based model specializes in financial sentiment analysis. Trained on earnings calls, market reports, and financial news, FinBERT accurately detects nuanced market sentiment that drives investor behavior. Banks use it for real-time market analysis with sub-50ms latency - impossible with larger models. **Manufacturing Excellence:** MAIRE automated routine engineering tasks with specialized models, saving over 800 working hours monthly. Engineers now focus on strategic activities instead of documentation. The key? Domain-specific SLMs that understand technical terminology without needing billion-parameter models. **Healthcare Transformation:** Hospitals deploy SLMs on edge devices for patient monitoring. These models analyze wearable sensor data locally, preserving privacy while enabling continuous health risk identification. No cloud dependency. No data transfer. Just reliable, real-time insights. ### Optimization techniques specific to SLMs **Token caching and embedding reuse:** SLMs benefit enormously from intelligent caching. Common phrases, form fields, and UI elements can be pre-computed and reused. ```python # Embedding cache for common business terms class SLMEmbeddingCache: def __init__(self, model_size="small"): self.cache = {} self.common_terms = [ "invoice", "purchase_order", "approval", "submit", "review", "process", "complete" ] self.precompute_embeddings() def precompute_embeddings(self): """Pre-calculate embeddings for common terms""" for term in self.common_terms: self.cache[term] = self.model.encode(term) def get_embedding(self, text: str): """Retrieve cached or compute new embedding""" if text in self.cache: return self.cache[text] embedding = self.model.encode(text) self.cache[text] = embedding # Cache for future use return embedding ``` **Batch processing with strict limits:** SLMs excel at batch processing when you respect their limits. Process 10 invoices simultaneously instead of one 10-page report. **Model-specific quantization:** Each SLM family has optimal quantization levels: - Gemma models: Q5_K_M maintains quality while cutting memory by 40% - Qwen models: Q4_0 offers best speed/quality balance - TinyLlama: Can run at Q2_K for extreme efficiency ### Safety and reliability in SLM deployments Smaller models mean more predictable behavior. That's a feature, not a bug. **Multi-layer safety architecture:** ```python class SLMSafetyFramework: def __init__(self): self.intent_validator = TinyLlama() # Quick sanity check self.action_verifier = Gemma2B() # Confirm actions self.result_checker = CodeLogic() # Deterministic validation def safe_execute(self, task: str): # Layer 1: Intent validation (50ms) if not self.intent_validator.is_safe(task): return self.escalate_to_human() # Layer 2: Action verification (200ms) actions = self.action_verifier.plan_actions(task) if not self.verify_actions_safe(actions): return self.request_approval() # Layer 3: Result checking (deterministic) result = self.execute_actions(actions) return self.result_checker.validate(result) ``` This layered approach catches issues early while maintaining millisecond response times. ### The bottom line for business automation Small Language Models aren't a compromise - they're a strategic choice for business process automation. When integrated with Tallyfy's orchestration capabilities, they deliver: - **Immediate deployment**: Run on existing hardware today - **Predictable costs**: No surprise API bills or token limits - **Reliable performance**: Consistent sub-second response times - **Complete privacy**: All processing stays within your infrastructure - **Practical scale**: Handle thousands of routine tasks efficiently The future of business automation isn't waiting for the next 1-trillion parameter model. It's here now, running efficiently on the laptop sitting on your desk. ## Hardware requirements and optimization Want to deploy local Computer Use Agents successfully? You'll need to understand hardware requirements and optimization strategies for different scenarios. ### Minimum and recommended specifications **Entry-Level Deployment (Basic Automation):** - **GPU**: 8GB VRAM (RTX 4060, RTX 3070, or RTX 3090 used at ~$950) - **RAM**: 16GB system memory - **Models**: Gemma 3n E2B (2GB), DeepSeek-R1 8B, Qwen3 4B, Phi-4 14B - **Performance**: 15-25 tokens/second, suitable for simple UI automation - **Special Note**: Gemma 3n E2B provides full multimodal capabilities in just 2GB VRAM, leaving room for other applications **SLM-First Deployment (Optimal for Business Tasks):** - **GPU**: 4-8GB VRAM (even older GPUs work well) - **RAM**: 8-16GB system memory - **Models**: TinyLlama 1.1B, Gemma 2B, Qwen2.5 3B, Phi-3 Mini - **Performance**: 50-100 tokens/second for micro models, perfect for structured tasks - **Business Impact**: Handles 95% of routine automation with minimal hardware **Professional Deployment (Advanced Workflows):** - **GPU**: 24GB VRAM (RTX 4090), 32GB VRAM (RTX 5090) - **RAM**: 32GB system memory - **Models**: DeepSeek-R1 32B, Qwen3 30B-A3B, Llama 4 Scout (17B active) - **Performance**: 35-60 tokens/second, handles complex multi-step processes - **RTX 5090 Specs**: 21,760 CUDA cores, 32GB GDDR7, 575W TGP, 1.79TB/s bandwidth **Enterprise Deployment (Production Scale):** - **GPU**: 40-80GB VRAM (A100, H100, NVIDIA DGX Spark at $3,999) - **RAM**: 64GB+ system memory - **Models**: All models including DeepSeek-R1 685B, Qwen3 235B, Llama 4 Maverick - **Performance**: 80+ tokens/second (156.7 tokens/s on A100 with Qwen3), supports concurrent agent instances ### Platform-specific optimization and implementation **Windows Optimization:** Windows offers the most mature ecosystem for local Computer Use Agents, with full automation frameworks and APIs: ```python # Windows UI Automation integration example import comtypes.client import pyautogui from typing import Optional class WindowsComputerUseAgent: def __init__(self): self.uia = comtypes.client.CreateObject("CUIAutomation.CUIAutomation") self.root = self.uia.GetRootElement() def find_element_by_name(self, name: str) -> Optional[object]: """Find UI element using Windows UI Automation""" condition = self.uia.CreatePropertyCondition( self.uia.UIA_NamePropertyId, name ) return self.root.FindFirst(self.uia.TreeScope_Descendants, condition) def click_element(self, element_name: str) -> bool: """Click element using native UI Automation""" element = self.find_element_by_name(element_name) if element: # Use native UI Automation invoke pattern invoke_pattern = element.GetCurrentPattern( self.uia.UIA_InvokePatternId ) invoke_pattern.Invoke() return True return False def fallback_to_vision(self, screenshot_path: str, target_text: str): """Fallback to vision-based control when UI Automation fails""" location = pyautogui.locateOnScreen(target_text, confidence=0.8) if location: pyautogui.click(pyautogui.center(location)) return True return False ``` Windows-specific optimizations: - **UI Automation (UIA)**: Access to element trees, properties, and control patterns - **Win32 APIs**: Low-level system interaction and window management - **PowerShell Integration**: Script automation and system administration - **DirectX Capture**: High-performance screen capture for visual processing **macOS Deployment:** Apple Silicon provides exceptional efficiency for local AI deployment with specialized optimization: ```python # macOS implementation using PyObjC and Accessibility import Quartz import ApplicationServices from AppKit import NSWorkspace from typing import Tuple, Optional class MacOSComputerUseAgent: def __init__(self): self.workspace = NSWorkspace.sharedWorkspace() def capture_screen(self) -> Quartz.CGImageRef: """Capture screen using Quartz Core Graphics""" return Quartz.CGWindowListCreateImage( Quartz.CGRectInfinite, Quartz.kCGWindowListOptionOnScreenOnly, Quartz.kCGNullWindowID, Quartz.kCGWindowImageDefault ) def accessibility_click(self, x: int, y: int): """Perform click using Accessibility API""" # Create click event click_event = Quartz.CGEventCreateMouseEvent( None, Quartz.kCGEventLeftMouseDown, (x, y), Quartz.kCGMouseButtonLeft ) Quartz.CGEventPost(Quartz.kCGHIDEventTap, click_event) # Release click release_event = Quartz.CGEventCreateMouseEvent( None, Quartz.kCGEventLeftMouseUp, (x, y), Quartz.kCGMouseButtonLeft ) Quartz.CGEventPost(Quartz.kCGHIDEventTap, release_event) def get_ui_elements(self, app_name: str) -> list: """Get UI elements using Accessibility API""" running_apps = self.workspace.runningApplications() target_app = None for app in running_apps: if app.localizedName() == app_name: target_app = app break if target_app: # Access accessibility elements return self._get_accessibility_elements(target_app) return [] ``` macOS-specific features: - **Metal Performance Shaders**: GPU acceleration for AI model inference - **Core ML Integration**: Optimized local model execution - **Accessibility API**: Native UI element access and control - **AppleScript Integration**: System-level automation capabilities **Linux Configuration:** Linux environments offer maximum customization and performance optimization: ```python # Linux implementation using AT-SPI and X11 import gi gi.require_version('Atspi', '2.0') from gi.repository import Atspi import Xlib.display import Xlib.X from typing import List, Optional class LinuxComputerUseAgent: def __init__(self): self.display = Xlib.display.Display() Atspi.init() def find_accessible_elements(self, role: str) -> List[Atspi.Accessible]: """Find elements using AT-SPI accessibility""" desktop = Atspi.get_desktop(0) elements = [] def search_recursive(accessible): try: if accessible.get_role_name() == role: elements.append(accessible) for i in range(accessible.get_child_count()): child = accessible.get_child_at_index(i) search_recursive(child) except: pass for i in range(desktop.get_child_count()): app = desktop.get_child_at_index(i) search_recursive(app) return elements def x11_click(self, x: int, y: int): """Perform click using X11""" root = self.display.screen().root # Mouse button press root.warp_pointer(x, y) self.display.sync() # Button press and release root.ungrab_pointer(Xlib.X.CurrentTime) fake_input = self.display.get_extension('XTEST') fake_input.fake_input(Xlib.X.ButtonPress, 1) fake_input.fake_input(Xlib.X.ButtonRelease, 1) self.display.sync() def containerized_deployment(self): """Setup for containerized agent deployment""" # Xvfb virtual display configuration # Docker container with GUI support # VNC server for remote access pass ``` Linux-specific advantages: - **AT-SPI Accessibility**: Comprehensive UI element access across desktop environments - **X11/Wayland Integration**: Low-level display server interaction - **Container Orchestration**: Kubernetes-based scaling and management - **Custom Kernel Modules**: Hardware-specific optimizations ### Memory optimization and quantization Modern quantization techniques and architectural innovations let you run larger models on consumer hardware: **Architectural Efficiency Breakthroughs:** - **Gemma 3n Per-Layer Embeddings**: Native memory efficiency - 8B parameter performance in just 3GB footprint without traditional quantization - **MatFormer Architecture**: Dynamic scaling lets a single model operate at multiple efficiency levels - **MXFP4 Format**: Native support in Ollama and OpenAI models for 4-bit mixed precision **Traditional Quantization Approaches:** - **Q4_K_M Quantization**: Cuts memory usage by 65% with minimal quality loss - **Q8_0 Quantization**: Balances quality and efficiency for production use - **INT4/INT2 Quantization**: New extreme compression achieving 10-30% performance improvements - **KV-Cache Quantization**: Another 20-30% memory savings for long contexts - **Dynamic Loading**: Smart model swapping based on task requirements **Gemma 3n is a game-changer** - it achieves memory efficiency through architecture rather than post-training quantization. Better quality retention. Native multimodal capabilities. ## Implementation architecture with Tallyfy Integrating local Computer Use Agents with Tallyfy creates a powerful hybrid automation platform. You get process orchestration plus intelligent computer control. ### Agent-Tallyfy integration patterns The integration between Tallyfy and local Computer Use Agents creates a powerful bidirectional workflow: [Diagram removed for brevity] **What to notice:** - Tallyfy provides structured instructions and data to the local agent through tasks and form fields - The agent executes actions locally with complete privacy and returns results to Tallyfy - All execution is trackable with audit logs and human oversight checkpoints **1. Task-Triggered Automation** When a Tallyfy [task](/products/pro/tracking-and-tasks/tasks/) requires computer interaction, the local agent receives: - Clear step-by-step instructions from the task description - Input data from Tallyfy [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) - Success criteria and expected outputs - Error handling and fallback procedures **2. Trackable AI Execution** Tallyfy's "Trackable AI" framework ensures complete visibility: - Real-time monitoring of agent actions and progress - Screenshot and action logging for audit trails - Human oversight checkpoints for critical decisions - Automatic rollback capabilities for error recovery **3. Process Continuation** Upon task completion, the agent returns: - Structured output data for Tallyfy form fields - Confirmation of successful completion - Any extracted data or generated artifacts - Error reports or exception conditions ### Example integration workflow Let's say you're automating supplier portal data extraction within a Tallyfy procurement process: ``` Tallyfy Process Step: "Extract Monthly Invoice Data from Supplier Portal" Input from Tallyfy: - Supplier portal URL: https://portal.supplier.com - Login credentials (securely stored) - Invoice date range: Previous month - Expected data fields: Invoice number, amount, due date Local Agent Execution: 1. Navigate to supplier portal 2. Perform secure login using stored credentials 3. Navigate to invoice section 4. Filter by date range 5. Extract invoice data using OCR and form recognition 6. Structure data according to Tallyfy field requirements 7. Handle any CAPTCHAs or verification prompts Output to Tallyfy: - Structured invoice data in designated form fields - PDF downloads attached to process - Completion status and execution log - Any exceptions or manual review requirements ``` ### Security and safety measures Local deployment enables complete security controls: - **Sandboxed Execution**: Run agents in isolated virtual machines or containers - **Permission Controls**: Limit agent capabilities to specific applications and data - **Human Approval Gates**: Require confirmation for sensitive or irreversible actions - **Audit Logging**: Complete action history for compliance and debugging - **Emergency Stop**: Immediate agent termination and rollback capabilities ## Performance benchmarks and capabilities Real-world testing shows local Computer Use Agents achieve remarkable performance across diverse automation scenarios. ### Benchmark results across hardware configurations **RTX 5090 (32GB GDDR7) Performance:** - DeepSeek-R1 32B: 156 tokens/second, 94% GPU utilization - Qwen3 235B-A22B: 89 tokens/second with MoE routing - GPT-OSS 120B: 256 tokens/second (35% faster than RTX 4090) **RTX 4090 (24GB VRAM) Performance:** - DeepSeek-R1 32B: 68.5 tokens/second, 94% GPU utilization - Qwen3 30B-A3B: 28.7 tokens/second, 84% efficient MoE routing - Llama 4 Scout: 45.2 tokens/second with 10M context support **RTX 4070 (12GB VRAM) / RTX 5070 Ti Performance:** - DeepSeek-R1 8B: 45.2 tokens/second, optimal for most automation tasks - Qwen3 7B: 52.8 tokens/second, excellent balance of speed and capability - Phi-4 14B: 38.9 tokens/second, efficient reasoning and planning - RTX 5070 Ti: 114.71 tokens/second at $940 retail **Apple M3 Max (128GB Unified Memory):** - DeepSeek-R1 8B: 34.8 tokens/second via MLX optimization - Native macOS integration with Accessibility API - Extended context handling due to unified memory architecture **Detailed Performance Analysis:** Recent benchmarking reveals specific performance characteristics across different deployment scenarios: ```python # Performance benchmarking data from real-world testing performance_benchmarks = { "deepseek_r1_8b": { "rtx_4090": {"tokens_per_second": 68.5, "gpu_utilization": 94, "vram_usage": "6.2GB"}, "rtx_4070": {"tokens_per_second": 45.2, "gpu_utilization": 91, "vram_usage": "5.8GB"}, "m3_max": {"tokens_per_second": 34.8, "gpu_utilization": 87, "memory_usage": "8.1GB"} }, "qwen3_30b_a3b": { "rtx_4090": {"tokens_per_second": 28.7, "gpu_utilization": 84, "vram_usage": "18.4GB"}, "rtx_4070": {"tokens_per_second": 12.3, "gpu_utilization": 96, "vram_usage": "11.7GB"}, "a100_40gb": {"tokens_per_second": 156.7, "gpu_utilization": 78, "vram_usage": "22.1GB"} }, "llama4_109b": { "rtx_4090": {"tokens_per_second": 12.1, "gpu_utilization": 99, "vram_usage": "24GB+"}, "a100_40gb": {"tokens_per_second": 45.2, "gpu_utilization": 85, "vram_usage": "38.9GB"}, "h100_80gb": {"tokens_per_second": 89.3, "gpu_utilization": 82, "vram_usage": "67.2GB"} } } # Agent accuracy rates across different task categories task_accuracy_benchmarks = { "web_form_completion": {"success_rate": 94.2, "error_recovery": 96.8}, "application_navigation": {"success_rate": 91.7, "ui_adaptation": 89.3}, "data_extraction": {"success_rate": 96.8, "ocr_accuracy": 98.1}, "file_management": {"success_rate": 98.1, "safety_compliance": 99.2}, "email_processing": {"success_rate": 93.4, "content_understanding": 91.7} } ``` ### Task completion accuracy rates Recent testing revealed impressive accuracy across automation categories: - **Web Form Completion**: 94.2% success rate with error recovery - **Application Navigation**: 91.7% successful goal achievement - **Data Extraction**: 96.8% accuracy with OCR verification - **File Management**: 98.1% reliable completion - **Email Processing**: 93.4% with content understanding ### Latency and responsiveness comparison Local agents crush cloud alternatives in response time: - **Local Agent Average**: 2.8 seconds per action cycle - **Cloud Agent Average**: 8.2 seconds per action cycle - **Network Elimination**: 65% latency reduction - **Consistent Performance**: No degradation during peak usage periods ## Deployment strategies and best practices Successful local Computer Use Agent deployment needs careful planning and proven best practices. ### Development and testing approach **Start Small and Scale:** Start with simple, low-risk automation tasks. Build confidence. Refine your processes. Focus on repetitive, well-defined workflows first - then tackle complex decision-making scenarios. **Comprehensive Testing Framework:** - **Sandbox Environment**: Test all automation thoroughly in isolated environments - **Progressive Validation**: Verify each step before adding complexity - **Error Scenario Testing**: Ensure reliable handling of edge cases and failures - **Performance Monitoring**: Establish baseline metrics and optimization targets ### Production deployment architecture **High Availability Configuration:** - **Primary Agent**: Main automation instance with full model capabilities - **Backup Systems**: Secondary agents for redundancy and load distribution - **Health Monitoring**: Continuous system health and performance tracking - **Automatic Failover**: Seamless switching to backup systems during issues **Resource Management:** - **Dynamic Model Loading**: Load appropriate models based on task complexity - **Memory Optimization**: Intelligent caching and model quantization - **GPU Scheduling**: Efficient utilization of compute resources - **Background Processing**: Queue management for batch automation tasks ### Monitoring and maintenance **Performance Monitoring:** - **System Resource Usage**: CPU, GPU, memory utilization tracking - **Agent Performance Metrics**: Task completion rates, execution times, error frequencies - **Model Accuracy Tracking**: Ongoing validation of automation success rates - **Capacity Planning**: Predictive analysis for hardware scaling requirements **Continuous Improvement:** - **Feedback Collection**: User input on agent performance and accuracy - **Model Updates**: Regular deployment of improved AI models - **Process Optimization**: Refinement of automation workflows based on usage data - **Training Data Enhancement**: Custom fine-tuning for organization-specific tasks ## Cost analysis and ROI Local Computer Use Agent deployment delivers compelling economic advantages over cloud-based alternatives. ### Total cost of ownership comparison **Local Deployment Investment:** - **Hardware**: $3,000-$8,000 for professional-grade systems - **Software**: Open-source models eliminate licensing costs - **Maintenance**: Internal IT resources for system management - **Electricity**: Approximately $50-150/month for continuous operation **Cloud Service Costs (Annual):** - **OpenAI Operator**: $2,400/year ($200/month subscription) - **Claude Pro**: $240/year with weekly rate limits - **UiPath Pro**: $5,040/year ($420/month), Unattended: $16,560/year - **Automation Anywhere**: $9,000/year Cloud Starter ($750/month) - **Workato Enterprise**: $15,000-50,000/year (task-based pricing) - **Make.com Pro**: $192/year (unlimited workflows, operation-based) - **n8n Cloud Pro**: $600/year (execution-based, unlimited workflows) - **Microsoft Power Automate**: $180/year per user (Premium plan) - **Tray.ai Platform**: $17,400+/year (starting at $1,450/month) - **Enterprise API Usage**: $5,000-25,000/year depending on volume - **Data Transfer**: Additional costs for high-volume automation - **Scaling Limitations**: Rate limits and usage restrictions ### The hidden costs cloud vendors don't advertise Industry surveys reveal something striking - a significant portion of IT decision-makers are developing AI in-house, specifically citing cost and control concerns. Why? The real TCO tells a different story than vendor pricing pages. **Actual enterprise cloud AI costs (3-year TCO):** - **Mid-size deployment**: $91,000-145,000 (cloud) vs $45,000 (local after hardware) - **Enterprise scale**: $550,000-1,090,000 (cloud) vs $180,000 (local with infrastructure) - **Usage-based surprises**: Companies report 2x-5x budget overruns from unexpected API calls - **Data egress fees**: Moving results out of cloud platforms adds 15-30% to base costs **The breakeven point:** Most organizations hit ROI on local deployment within 6-12 months for routine automation tasks. Advanced AI copilots take 18-24 months. But here's the kicker - after year two, you're essentially running for free while cloud costs keep climbing. **Real enterprise decisions:** - A growing number of companies now consider on-premises equal to cloud for new applications - Major vendors report significant enterprise movement of AI workloads from cloud to edge - Financial services leads the shift - with many preferring local deployment for compliance reasons ### Tallyfy pricing model for local agents Tallyfy will implement revolutionary **per-minute usage pricing** for local Computer Use Agent integration: - **Transparent Metering**: Pay only for active agent execution time - **No Subscription Fees**: Eliminate fixed monthly costs - **Predictable Scaling**: Cost directly correlates with automation value - **Volume Discounts**: Reduced rates for high-usage deployments This model aligns costs with actual value delivery. Organizations get complete control over their automation investment. ### Return on investment scenarios **Small Business (10-20 automated tasks/day):** - **Cost Savings**: $15,000-30,000/year in labor costs - **Cloud Alternative Costs**: Make.com ($192/year) or n8n Cloud Pro ($600/year) for similar automation - **Efficiency Gains**: Significant productivity increases - **ROI Timeline**: 3-6 months payback period - **Market Context**: Strong executive adoption of AI automation **Enterprise (100+ automated tasks/day):** - **Cost Savings**: $150,000-500,000/year in operational efficiency - **Cloud Platform Comparison**: UiPath Enterprise ($20,000+/year), Automation Anywhere ($10,000+/year) - **Competitive Advantage**: Substantial efficiency gains and improved accuracy - **Industry Trend**: Rapidly growing workflow automation market - **ROI Timeline**: Strong ROI within first year ### Proven ROI from real deployments **Microsoft Copilot implementations showcase dramatic returns:** - **HELLENiQ ENERGY**: 70% productivity boost, 64% reduction in email processing time - **Ma'aden**: 2,200 hours saved monthly through task automation - **NTT DATA**: 65% automation in IT service desks, 100% in certain order workflows - **Fujitsu**: 67% reduction in sales proposal production time These aren't pilot programs - they're production deployments generating measurable business value today. **The MIT reality check:** MIT research found that a large majority of AI pilots fail to achieve rapid revenue growth. But here's what separates those that succeed: they focus on back-office automation with domain-specific models, not general-purpose AI. Companies that partner with specialized vendors succeed at significantly higher rates than those that build internally. The lesson? Start with focused SLMs for specific tasks. Build on proven platforms like Tallyfy. Measure everything. ## Future roadmap and developments Tallyfy's local Computer Use Agent initiative is just the beginning. We're transforming business automation. ### The enterprise AI reality check Let's be honest about where we are. MIT/NANDA research revealed that a large majority of generative AI pilots fail to deliver measurable P&L impact. But those that succeed share common traits: - They focus on specific, bounded tasks rather than general intelligence - They prioritize back-office automation over customer-facing applications - They partner with specialized vendors instead of building internally - They measure ROI relentlessly from day one Tallyfy positions you in that successful group by providing the orchestration layer that turns AI potential into business results. ### Near-term enhancements **Advanced Model Integration:** - **Reasoning Models**: Advanced reasoning models with extended reasoning chains - **Specialized Models**: Industry-specific fine-tuned agents including various multimodal options - **Multimodal Expansion**: Comprehensive audio, video, and vision processing in production-ready local models - **Market Integration**: Strong and growing workflow automation market with high executive adoption **Platform Improvements:** - **Cross-Platform Deployment**: UFO2 for Windows, unified agents across all platforms - **Container Orchestration**: Kubernetes-based scaling with significant latency reduction - **Edge Computing**: Specialized edge AI chips with excellent performance-per-watt ratios - **Framework Maturity**: Leading frameworks like AutoGen, LangGraph, and CrewAI with strong community adoption ### Medium-term vision **Autonomous Workflow Management:** - **Self-Improving Agents**: AI that learns and optimizes from experience - **Dynamic Task Planning**: Agents that break down complex goals automatically - **Collaborative Agent Networks**: Multiple specialized agents working together **Enterprise Integration:** - **ERP System Integration**: Native connectivity with major business systems - **Compliance Automation**: Built-in regulatory and audit trail management - **Advanced Analytics**: AI-powered insights into automation performance ### Long-term transformation **Cognitive Business Automation:** - **Natural Language Process Design**: Describe workflows in plain English - **Predictive Automation**: Anticipate needs and proactively execute tasks - **Adaptive Intelligence**: Agents that evolve with changing business requirements **Industry Revolution:** - **Democratized Automation**: AI agents accessible to any organization - **New Business Models**: Automation-first operational strategies - **Human-AI Collaboration**: Seamless integration of human judgment with AI execution ### Emerging model architectures and optimization trends Several breakthrough architectural innovations drive the rapid evolution of local Computer Use Agents: **Mixture of Experts (MoE) Architectures:** Models like Qwen3 30B-A3B show how MoE delivers large model capabilities with efficient resource usage: ```python # MoE efficiency analysis moe_efficiency_comparison = { "qwen3_30b_a3b": { "total_parameters": "30B", "active_parameters": "3B", "efficiency_ratio": 10.0, "performance_retention": 0.94 }, "llama4_109b": { "total_parameters": "109B", "active_parameters": "17B", "efficiency_ratio": 6.4, "performance_retention": 0.97 } } ``` **Advanced Quantization Innovations:** Next-generation quantization techniques push the boundaries of consumer hardware: - **INT4 with Quality Retention**: New algorithms maintain 97%+ quality with 4-bit quantization - **Dynamic Quantization**: Runtime adaptation based on content complexity - **KV-Cache Compression**: Advanced compression of attention caches for extended context windows - **Speculative Quantization**: Predictive quantization based on task requirements **Agentic Workflow Architectures:** The shift toward agentic workflows enables more sophisticated autonomous operation: ```python # Agentic workflow framework example class AgenticWorkflowManager: def __init__(self): self.planner_agent = PlannerAgent() self.executor_agents = { "web": WebExecutorAgent(), "desktop": DesktopExecutorAgent(), "data": DataProcessingAgent() } self.validator_agent = ValidatorAgent() def execute_complex_goal(self, high_level_goal: str): """Break down and execute complex multi-step goals""" # 1. Plan: Decompose goal into subtasks subtasks = self.planner_agent.decompose_goal(high_level_goal) # 2. Execute: Route subtasks to appropriate agents results = [] for subtask in subtasks: agent_type = self.planner_agent.select_agent(subtask) result = self.executor_agents[agent_type].execute(subtask) results.append(result) # 3. Validate: Ensure overall goal achievement return self.validator_agent.validate_goal_completion( high_level_goal, results ) ``` **Edge Computing Optimizations:** Specialized architectures for resource-constrained deployment: - **Neural Architecture Search (NAS)**: Automated optimization for specific hardware configurations - **Pruning and Distillation**: Reducing model size while preserving computer use capabilities - **Federated Learning**: Distributed training across multiple local deployments - **Hardware Co-design**: Models optimized for specific GPU architectures (RDNA, Ada Lovelace, etc.) ## Getting started with local computer use agents Ready to embrace the future of automation? Begin your local Computer Use Agent journey with Tallyfy. ### The practical path: start with small language models Here's our recommendation - start small, prove value, then scale. Begin with SLMs for your routine automation tasks. They're running in production today at thousands of organizations. **Week 1: Deploy your first SLM agent** ```bash # Install TinyLlama for intent classification ollama pull tinyllama # Install Gemma 2B for task execution ollama pull gemma:2b # Test on a simple form filling task echo "Fill out the purchase order form with vendor ACME Corp" | \ llm -m tinyllama "Classify this task: form_fill, data_extract, or email_process" ``` **Week 2: Automate your first workflow** - Pick one repetitive task (invoice processing, form submission, data entry) - Create structured prompts optimized for SLMs - Integrate with Tallyfy for orchestration - Measure time saved and accuracy achieved **Week 3: Scale to production** - Deploy multiple specialized SLMs for different task types - Implement the hybrid architecture (SLM + selective escalation) - Add monitoring and safety layers - Document ROI for stakeholder buy-in This approach gets you operational immediately while building toward more sophisticated automation. ### Quick start with Gemma 3n **Immediate deployment** - Gemma 3n's day-one support makes it the fastest way to get started with local multimodal agents: ```bash # Install via Ollama (easiest option) ollama pull gemma3n llm install llm-ollama llm -m gemma3n:latest "Analyze this screenshot and suggest automation opportunities" # Or use MLX on Apple Silicon for full multimodal capabilities uv run --with mlx-vlm mlx_vlm.generate \ --model gg-hf-gm/gemma-3n-E4B-it \ --prompt "Transcribe and analyze this interface" \ --image screenshot.jpg ``` **Production advantages of Gemma 3n for Computer Use Agents:** - **Single Model Deployment**: No need for separate vision/audio models - **Memory Efficiency**: Fits in entry-level hardware while providing advanced capabilities - **Comprehensive I/O**: Handles screenshots, audio commands, and video analysis in one model - **Production Ecosystem**: Works immediately with existing MLOps pipelines ### Readiness assessment **Technical Prerequisites:** - Modern hardware with adequate GPU memory (minimum 8GB VRAM) - Stable network infrastructure for Tallyfy integration - IT team familiar with AI deployment and management - Identified automation use cases with clear success criteria **Organizational Requirements:** - Executive sponsorship for automation initiatives - Process documentation and optimization readiness - Change management planning for workflow transformation - Security and compliance framework for AI deployment ### Implementation pathway **Phase 1: Foundation (Months 1-2)** - Hardware procurement and setup - Tallyfy platform configuration - Initial model deployment and testing - Team training and capability building **Phase 2: Pilot Deployment (Months 3-4)** - Select 3-5 high-value automation use cases - Develop and test automation workflows - Implement monitoring and error handling - Gather user feedback and performance data **Phase 3: Production Scale (Months 5-6)** - Expand automation to full workflow coverage - Implement advanced features and optimizations - Establish ongoing maintenance and improvement processes - Document ROI and business impact ### Support and resources Tallyfy provides full support for local Computer Use Agent deployment: - **Technical Documentation**: Detailed implementation guides and best practices - **Expert Consultation**: Direct access to AI automation specialists - **Community Resources**: User forums and knowledge sharing platforms - **Ongoing Updates**: Regular model updates and feature enhancements ## The strategic imperative The cost of AI has dropped dramatically. LLM inference now costs the same as a basic web search. The global SLM market is experiencing rapid growth. Edge computing is processing an increasing majority of enterprise data. These aren't future trends - they're current realities reshaping business automation. ### Why Tallyfy leads the local AI revolution We're not chasing the latest GPT model or building another chatbot. We're solving real business problems with proven technology: **Immediate value delivery:** - Deploy on existing hardware - no $120,000 GPU clusters required - Run proven models like TinyLlama and Gemma that work today - Automate mundane tasks that consume 40% of knowledge worker time - Achieve ROI in months, not years **Built for how businesses actually work:** - Structured workflows, not open-ended conversations - Trackable execution with complete audit trails - Human oversight at critical decision points - Integration with existing business systems **The competitive advantage:** While competitors debate cloud vs. local, we've built the platform that orchestrates both. Use small models for routine tasks. Escalate to larger models when needed. Keep sensitive data local. Access cloud capabilities on demand. This isn't about choosing sides in the AI wars. It's about getting work done. ### Your next step The future of business automation? Local, private, and intelligent. With Tallyfy's local Computer Use Agents, you'll achieve unprecedented automation capabilities while maintaining complete control over your data and processes. Start small. A single workflow. One repetitive task. Prove the value. Then scale. Contact our team to begin your journey toward autonomous business operations with local Computer Use Agents. Or better yet - download TinyLlama today and see what's possible on the laptop you already own. ## Challenges and best practices for offline deployment Implementing cutting-edge Computer Use Agents entirely locally brings unique challenges. You'll need careful consideration and proven best practices. ### Technical challenges and solutions **Computational Load Management:** Large multimodal models demand a lot from local hardware. Processing screenshots and generating complex instructions? That requires significant GPU memory for real-time performance. ```python # Example optimization strategies for resource management class ResourceOptimizer: def __init__(self): self.model_cache = {} self.quantization_levels = { "high_quality": 8, "balanced": 4, "aggressive": 2 } def optimize_for_hardware(self, available_vram_gb: int): """Select optimal model configuration based on available resources""" if available_vram_gb >= 24: return { "model_size": "32b", "quantization": "high_quality", "batch_size": 4, "kv_cache": "q8_0" } elif available_vram_gb >= 12: return { "model_size": "8b", "quantization": "balanced", "batch_size": 2, "kv_cache": "q4_0" } else: return { "model_size": "1.5b", "quantization": "aggressive", "batch_size": 1, "kv_cache": "q2_k" } def dynamic_model_loading(self, task_complexity: str): """Load appropriate model based on task requirements""" model_mapping = { "simple": "phi4:14b", "moderate": "qwen3:8b", "complex": "deepseek-r1:32b" } return model_mapping.get(task_complexity, "qwen3:8b") ``` **Accuracy and Error Handling:** AI agents still misclick or misinterpret interfaces sometimes. You need reliable verification and error recovery: ```python # Error handling and verification framework class AgentVerificationSystem: def __init__(self): self.action_history = [] self.verification_strategies = [] def verify_action_result(self, intended_action: str, screenshot_before: str, screenshot_after: str) -> bool: """Verify if the intended action was successful""" # Template matching verification if self._template_match_verification(intended_action, screenshot_after): return True # Text detection verification if self._text_detection_verification(intended_action, screenshot_after): return True # UI state change verification if self._ui_state_change_verification(screenshot_before, screenshot_after): return True return False def implement_rollback(self, steps_back: int = 1): """Rollback failed actions and retry with alternative approach""" for _ in range(steps_back): if self.action_history: last_action = self.action_history.pop() self._execute_reverse_action(last_action) ``` **Safety and Boundaries:** Local agents have the same power as human users. That means proper safety measures are essential: ```python # Safety framework for local agent deployment class AgentSafetyFramework: def __init__(self): self.restricted_actions = [ "delete_file", "format_drive", "send_email", "financial_transaction", "system_shutdown" ] self.approval_required = [ "file_deletion", "email_sending", "payment_processing" ] def safety_check(self, proposed_action: str) -> dict: """Comprehensive safety validation before action execution""" result = { "allowed": True, "requires_approval": False, "risk_level": "low", "restrictions": [] } # Check against restricted actions if any(restriction in proposed_action.lower() for restriction in self.restricted_actions): result["allowed"] = False result["risk_level"] = "high" # Check if approval required if any(approval in proposed_action.lower() for approval in self.approval_required): result["requires_approval"] = True result["risk_level"] = "medium" return result def sandbox_execution(self, agent_task: str): """Execute agent in sandboxed environment""" # Virtual machine isolation # Limited file system access # Network restrictions # Resource limitations pass ``` ### Cross-platform deployment considerations **Windows Deployment Best Practices:** - Use UFO2's HostAgent architecture for enterprise-grade reliability - Integrate with Windows UI Automation for hybrid control approaches - Try PowerToys OCR for text extraction without internet dependency - Implement thorough error handling for application-specific quirks **macOS Optimization Strategies:** - Utilize Apple's Accessibility API for native UI element access - Use MLX for hardware-optimized model inference on Apple Silicon - Implement AppleScript integration for system-level automation - Use VNC approach for consistent cross-application control **Linux Configuration Excellence:** - Deploy using container orchestration for scalability and isolation - Integrate AT-SPI for full accessibility across desktop environments - Utilize X11/Wayland automation for low-level display interaction - Implement custom kernel modules for hardware-specific optimizations ## Industry adoption and implementation trends The rapid adoption of local Computer Use Agents accelerates across industries. Major frameworks now dominate the ecosystem: **Leading Agent Frameworks:** - **Microsoft AutoGen**: Large community, strong adoption, event-driven architecture with Docker support - **LangGraph**: Significant community adoption, stateful graph-based agents with LangSmith monitoring - **CrewAI**: Strong community adoption, role-based architecture with human-in-the-loop integration **Inference Engine Performance:** - **vLLM**: 24x higher throughput using PagedAttention optimization - **llama.cpp**: CPU-optimized inference with SIMD instructions, 10-30% improvement with multiple GPUs - **TensorFlow Lite**: Mobile and embedded deployment for edge devices - **ONNX Runtime**: Cross-platform optimization with extensive hardware support These frameworks enable organizations to deploy local agents rapidly. AutoGen's event-driven architecture particularly excels for complex workflows. LangGraph's stateful design handles multi-step processes elegantly. CrewAI's role-based approach simplifies team automation scenarios. ## References and citations This guide builds on cutting-edge research and production implementations in the Computer Use Agent field. These sources provide the foundational knowledge and technical insights referenced throughout: **Primary Research Sources:** - OpenAI, *"Computer-Using Agent (CUA) – Powering Operator"* (January 2025) – Official introduction of the CUA model and Operator, describing how the agent interacts with GUIs and its performance on benchmarks - Cobus Greyling, *"How to Build an OpenAI Computer-Using Agent"* (March 2025) – Medium article explaining the loop of sending screenshots to the model and executing returned actions, based on OpenAI's API - Microsoft Research, *"UFO2: The Desktop AgentOS"* (ArXiv preprint 2024) – Research paper and open-source project detailing a Windows-focused agent system that combines UI Automation with vision; discusses limitations of earlier approaches and cross-OS possibilities - Runliang Niu et al., *"ScreenAgent: A Vision Language Model-driven Computer Control Agent"* (IJCAI 2024) – Research introducing a cross-platform agent using VNC, a custom dataset, and a model rivaling GPT-4V. Open-source code available on GitHub **Industry Analysis and Market Research:** - Kyle Wiggers, TechCrunch, *"Hugging Face releases a free Operator-like agentic AI tool"* (May 2025) – News article on Hugging Face's Open Computer Agent demo, highlighting the use of open models (Qwen-VL), performance quirks, and the growing enterprise interest in AI agents - *macOSWorld Benchmark (ArXiv 2025)* – Describes a benchmark for GUI agents on macOS, illustrating the use of VNC and listing standardized action spaces for cross-OS agent evaluation - KPMG Survey on AI Agent Adoption (2025) – Industry research showing 65% of companies experimenting with AI agents and enterprise adoption trends **Technical Implementation Resources:** - [DigitalOcean Community: Building Local AI Agents with LangGraph and Ollama](https://www.digitalocean.com/community/tutorials/local-ai-agents-with-langgraph-and-ollama) – Comprehensive technical tutorial on local AI agent implementation architectures - [Collabnix: Best Ollama Models 2025 Performance Comparison](https://collabnix.com/best-ollama-models-in-2025-complete-performance-comparison/) – Detailed performance benchmarks and optimization strategies for local model deployment **Open Source Projects and Frameworks:** - Microsoft UFO2 AgentOS (MIT License) – https://github.com/microsoft/UFO - ScreenAgent Cross-Platform Framework – https://github.com/niuzaisheng/ScreenAgent - Hugging Face SmoLAgents Framework – https://github.com/huggingface/smolagents - Agent S2 Open Computer Use Framework – https://github.com/simular-ai/Agent-S - AgenticSeek Local AI Agent Platform – https://github.com/Fosowl/agenticSeek **Performance Benchmarks and Datasets:** - WebVoyager Benchmark – Industry standard for web-based computer use evaluation - OSWorld Benchmark – Comprehensive OS-level task completion evaluation - SWE-bench Verified – Software engineering task completion assessment - GAIA Benchmark – General AI Assistant evaluation across difficulty levels These sources represent the cutting edge of Computer Use Agent research and development, providing the technical foundation for local deployment strategies and implementation best practices documented in this guide. - **[RPA vs. computer AI agents](https://tallyfy.com/products/pro/integrations/computer-ai-agents/rpa-vs-computer-use-agents/)**: This comprehensive guide explains how RPA handles structured repetitive tasks through rule-based automation while Computer AI Agents use artificial intelligence to adaptively navigate dynamic web environments and unstructured data with Tallyfy orchestrating both automation types within unified business processes. ## RPA vs. computer AI agents: choosing the right automation for Tallyfy You need to understand the difference between RPA and Computer AI Agents if you're serious about automation. Both can automate tasks, sure - but they're worlds apart in what they can actually do. Tallyfy orchestrates both types, but here's the thing: pick the wrong tool and you'll either burn money on overkill solutions or spend every Monday fixing broken scripts. [Diagram removed for brevity] **What to notice:** - Simple decision point: structured tasks go to RPA, unstructured go to AI Agents - Both paths lead to task completion but through different methods - Tallyfy orchestrates the choice and tracks the results :::warning[Important guidance for AI agent tasks] Your step-by-step instructions for the AI agent to perform work go into the Tallyfy [task](/products/pro/tracking-and-tasks/tasks/) description. **Start with short, bite-size and easy tasks that are just mundane and tedious.** Do not try and ask an AI agent to do huge, complex decision-driven jobs that are goal-driven - they are prone to indeterministic behavior, hallucination, and it can get very expensive quickly. Think "fill out this specific form" not "revolutionize our customer service." ::: ### Robotic process automation (RPA): the rule-follower RPA uses software "bots" that copy what humans do on computers - but only if it's repetitive and rule-based. Think of RPA as that coworker who follows directions perfectly but completely freezes when anything unexpected pops up. Zero improvisation skills. * **Core Function:** Automates high-volume, stable, and predictable tasks based on clearly defined rules and structured data inputs. * **Data Handling:** Mainly built for **structured data** – information organized in a consistent format (e.g., data in spreadsheets, databases, or standardized forms). * **How it Works:** RPA bots work with application user interfaces (UIs) or existing APIs by following a sequence of steps clearly defined by a developer (e.g., "Open application X, click button Y at coordinates (100,250), copy data from field Z, paste into application A, field B"). * **Adaptability & Resilience:** RPA is **not adaptive** - period. Move a button 10 pixels? The bot breaks. Rename a field? Broken. Change the data format slightly? You guessed it. Anyone who's maintained RPA bots knows that sinking feeling when you check your email Monday morning and see 47 error notifications. * **Decision Making:** Limited to simple, binary decisions based on pre-programmed rules (e.g., "IF field X contains 'Approved', THEN do Y, ELSE do Z"). It can't handle uncertainty, interpret subtle information, or make complex judgments. * **Cognitive Skill:** Low. RPA follows instructions literally and doesn't understand the *intent* behind the actions or the content it processes. * **Best Suited For:** * Legacy system integration where APIs aren't available. * Stable, high-volume data entry, validation, or migration between systems with fixed UIs. * Regular form filling with consistent layouts. * Creating standardized reports from structured data sources. * **Tallyfy Integration:** Tallyfy can start RPA bots for specific, well-defined [tasks](/products/pro/tracking-and-tasks/tasks/) in a larger [process](/products/pro/tracking-and-tasks/processes/). For example, a Tallyfy task could tell an RPA bot to take data from Tallyfy [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) and put it into an old mainframe system. Tallyfy manages the overall process flow, provides inputs, and tracks the completion and output of the RPA task. ### Computer AI agents: the adaptive problem-solver Computer AI Agents (you'll also hear them called AI Agents, Agentic AI, or Computer Use Agents) are a whole different beast. They use artificial intelligence - specifically Large Language Models for understanding language and computer vision to actually "see" what's on screen. Much more human-like. * **Core Function:** Automates more complex, often changing tasks that may need understanding context, interpreting varied inputs (including unstructured data), planning, and making decisions to reach a specific goal. * **Data Handling:** Can process both **structured and unstructured data** (e.g., text from emails, content on web pages, information in PDFs, on-screen visual elements, natural language instructions). * **How it Works:** Users usually give a goal, often in natural language (e.g., "Find the contact details for the main distributor of Product X in Germany and update their record in our web CRM"). The AI agent then uses its understanding of language and its ability to "see" and interpret a screen to create and execute a plan. This might involve web browsing, opening applications, dynamically finding and working with UI elements (buttons, forms), and typing text. * **Adaptability & Resilience:** AI Agents are **much more adaptive**. They handle UI changes like a pro because they understand what elements mean, not just where they are. Button moved? No problem - they'll find it. Text changed from "Submit" to "Send"? They get it. It's like having an intern who can actually think instead of just memorizing click coordinates. * **Decision Making:** Can make more complex, context-aware decisions. They can figure out meaning, handle some uncertainty, and plan or re-plan if they hit obstacles, aiming to reach the overall goal. * **Cognitive Skill:** Higher. AI agents try to interpret instructions, understand context, and reach goals, rather than just running a fixed sequence of clicks and keystrokes. They can do tasks that need some cognitive work. * **Best Suited For:** * Working with dynamic web applications or websites with frequently changing UIs. * Getting information from unstructured or semi-structured sources (e.g., scraping data from multiple varied product pages). * Tasks needing interpretation of on-screen information and visual context. * More open-ended research, data gathering, or summary tasks from web sources. * Handling exceptions or changes in a process flow more smartly. * **Tallyfy Integration:** Tallyfy defines a task goal (e.g., "Log into the supplier portal for Supplier Y, navigate to order history, find all POs from last month related to 'Project Alpha', and extract their total amounts and delivery dates.") and provides necessary input data. The Computer AI Agent then carries out these web interactions. Tallyfy ensures this is a **Trackable AI** step, managing the inputs, expected outputs, and its role within the end-to-end process, allowing for human oversight and intervention if needed. ### Key differences: beyond surface-level automation | Feature | Robotic Process Automation (RPA) | Computer AI Agents | | :------------------------- | :------------------------------------------- | :--------------------------------------------- | | **Primary Intelligence** | Rule-based execution | AI-driven understanding, reasoning, perception | | **Task Complexity** | Simple, repetitive, high-volume | Complex, dynamic, goal-oriented, multi-step | | **Adaptability to Change** | Low (brittle, breaks with UI changes) | High (can adapt to UI/content variations) | | **Data Handling** | Primarily Structured | Structured & Unstructured, visual | | **Setup & Maintenance** | Explicit programming, high maintenance | Goal definition (often NL), potentially lower maintenance for UI changes | | **Error Handling** | Requires pre-defined exception paths | Can attempt to self-correct or re-plan | | **Cognitive Load** | Automates manual execution | Automates tasks requiring some interpretation | ### The shift towards agentic workflows and democratized automation * **Agentic Workflows:** AI Agents create "agentic workflows" - they can plan, execute, and adapt over time to hit a goal. RPA? It just follows its script line by line. * **Democratization of Automation:** Here's what's exciting: you can tell AI Agents what to do in plain English. No coding required. Microsoft Copilot Studio, OpenAI Operator - they're making automation accessible to everyone, not just developers. Finally, automation that doesn't need a Computer Science degree. ### Tallyfy: orchestrating the evolving automation landscape Tallyfy sits perfectly in the middle of this automation evolution. Got stable, high-volume tasks? Use RPA. Need something that can handle messy, real-world web interactions? That's where AI Agents shine. Either way, Tallyfy gives you the framework to manage it all: * **Clear Process Definition:** Document every step, whether human, RPA, or AI Agent executed. * **Input/Output Management:** Provide structured data to your automations and capture their results in Tallyfy [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/). * **Human-in-the-Loop:** Seamlessly add human checkpoints for review and approval. When RPA hits an exception or when AI makes a big decision, humans step in. Simple. * **Trackable AI:** Every automated action is visible and accountable. You can monitor performance and improve over time - that's core to how Tallyfy works. * **Intelligent Process Automation (IPA):** Mix and match humans, RPA bots, and AI Agents in one workflow. Example: AI Agent does web research, passes data to RPA for legacy system entry, humans approve the results. Tallyfy manages all the handoffs. ### Limitations & the human element Let's be real: Computer AI Agents aren't perfect. They're advancing fast, but they still make mistakes, misread instructions, or get confused by weird edge cases. They're impressive, but not magic (yet). That's exactly why Tallyfy's human oversight features matter so much. You design workflows with human checkpoints - especially for critical decisions or external actions. Get the benefits of AI automation while keeping control where it counts. Here's the bottom line: it's not RPA vs. AI Agents. The smartest approach uses both. RPA handles the boring, predictable stuff. AI Agents tackle the dynamic web interactions that would have your RPA scripts crying for mercy. Tallyfy orchestrates the whole show. - **[AI agent vendors](https://tallyfy.com/products/pro/integrations/computer-ai-agents/vendors/)**: The computer AI agent market features enterprise-ready solutions like OpenAI Operator and Claude Computer Use alongside open-source options like Skyvern and Manus AI with each offering different strengths for automating web-based tasks that lack API access. ## AI agent products - commercial and open source The Computer AI Agent market has exploded. Let's cut through the noise. **Enterprise-Ready Leaders:** - **OpenAI Operator**: Consumer-focused, powered by Computer-Using Agent model, requires ChatGPT Pro subscription - **Claude Computer Use**: Developer-focused with strong benchmark performance - **Twin.so**: Enterprise partnerships, real-world deployment with European SMBs **Open-Source Innovation:** - **Skyvern**: Strong WebVoyager benchmark performance, transparent per-step pricing - **Manus AI**: Autonomous task completion, invite-only access Each vendor brings different strengths to the table - some excel at consumer tasks, others dominate developer workflows. You'll find detailed breakdowns of their technology, benchmarks, and real-world use cases below. We'll also show you exactly how to integrate them with Tallyfy, especially for those frustrating web tasks where APIs just don't exist. :::warning[Important guidance for AI agent tasks] Your step-by-step instructions for the AI agent to perform work go into the Tallyfy [task](/products/pro/tracking-and-tasks/tasks/) description. **Start with short, bite-size and easy tasks that are just mundane and tedious.** Do not try and ask an AI agent to do huge, complex decision-driven jobs that are goal-driven - they are prone to indeterministic behavior, hallucination, and it can get very expensive quickly. ::: Want the specifics? Check out each vendor page: ### Vendors - **[Claude computer use](https://tallyfy.com/products/pro/integrations/computer-ai-agents/vendors/claude-computer-use/)**: Claude's Computer Use capability enables AI agents to visually perceive and control computer interfaces through screenshots and mouse/keyboard actions within sandboxed Docker environments to automate repetitive desktop tasks like form filling and data extraction from legacy systems while requiring careful security isolation and human oversight due to current limitations around latency and error-prone execution. :::note[Information Currency Notice] This article describes Claude Computer Use capabilities. This feature is in public beta and evolving rapidly. Capabilities, pricing, and availability may change. Always verify current information at [Anthropic's official documentation](https://docs.anthropic.com). ::: ## Using Anthropic's Claude to complete tasks within Tallyfy Claude can now control computers by looking at screens, moving cursors, clicking buttons, and typing text. This "Computer Use" capability launched in October 2024 as a public beta feature available through Anthropic's API, Amazon Bedrock, and Google Cloud Vertex AI. :::warning[Important guidance for AI agent tasks] Your step-by-step instructions for the AI agent to perform work go into the Tallyfy [task](/products/pro/tracking-and-tasks/tasks/) description. **Start with short, bite-size and easy tasks that are just mundane and tedious.** Do not try and ask an AI agent to do huge, complex decision-driven jobs that are goal-driven - they are prone to indeterministic behavior, hallucination, and it can get very expensive quickly. ::: :::info[Claude Computer Use vs Claude MCP Integration] This article covers **Claude Computer Use** - where Claude visually perceives and controls computer interfaces through screenshots, mouse movements, and keyboard actions. This is different from [Claude's MCP integration](/products/pro/integrations/mcp-server/claude-anthropic/), which provides text-based chat access to data sources and APIs. **When to use each:** - **Claude Computer Use** (this article): For automating visual UI tasks that require seeing and interacting with interface elements (clicking buttons, filling forms, navigating menus) - **Claude MCP Integration**: For data queries, API-based workflow management, and text-based automation Both capabilities can complement each other in complete automation workflows. ::: ### Understanding Claude's computer use feature Instead of building thousands of app-specific integrations, Anthropic gave Claude general computer skills. Claude uses an API to see and interact with any application inside a sandboxed environment. [Diagram removed for brevity] **What to notice:** - Tallyfy provides the task description and expected outputs that guide Claude's actions - Claude loops through screenshot-analyze-act cycles until the task is complete - All results, logs, and screenshots are captured back into Tallyfy fields ### Current model support and performance **Available models with Computer Use:** - **Claude Opus 4.5** - The flagship model, best for complex computer use tasks - **Claude Sonnet 4** - Primary model for most computer use automation - **Claude Haiku 4.5** - Available for simpler, faster automation tasks **Performance benchmarks:** - Claude Sonnet 4.5 achieved 61.4% on OSWorld (up from 42.2% with Sonnet 4) - Human performance on OSWorld remains at 72.4% - The feature is still experimental and error-prone at this stage ### How the Claude computer use agent loop works This diagram shows how Tallyfy orchestrates Claude's computer use capabilities through an iterative agent loop where Claude perceives, acts, and receives feedback until your task is complete. [Diagram removed for brevity] **What to notice:** - Tallyfy triggers your intermediary app via webhook with task data - The loop between Claude and the sandbox continues until the task is complete - All tool execution happens in an isolated sandbox for security ### Core components **Sandboxed Computing Environment:** The environment (typically a Docker container) includes: - A virtual X11 display server (like Xvfb) for rendering the desktop - A lightweight Linux desktop environment - Pre-installed applications (Firefox, LibreOffice, text editors) - Your implementations of the Anthropic-defined tools **Three Core Tools** (Anthropic-defined, user-executed): - **computer**: Mouse/keyboard actions (key presses, typing, cursor movement, clicks, scrolling) and taking screenshots - **text_editor**: View, create, and edit files within the environment - **bash**: Run shell commands in the sandboxed environment **Tool Versions:** - `computer_20250124` for newer models with enhanced actions - `computer_20241022` for legacy Claude 3.5 Sonnet models ### Pricing **API Pricing (verify current rates at Anthropic):** - **Claude Sonnet 4**: $3 per million input tokens, $15 per million output tokens - **Claude Haiku 4.5**: $0.80 per million input tokens, $4 per million output tokens - **Additional overhead**: Computer use adds 466-499 tokens to the system prompt **Access Requirements:** - Anthropic API key with sufficient credits - Available through Anthropic API, Amazon Bedrock, or Google Cloud Vertex AI - Docker required for the reference implementation ### Real-world use cases Computer Use works well for specific automation scenarios. Early adopters include Asana, Canva, Replit, and DoorDash. **Suitable applications:** - Automating form filling across desktop applications - Extracting data from legacy systems without APIs - QA and testing tasks with synthetic test case generation - Navigating multiple applications to complete multi-step workflows - Desktop navigation and file management tasks **Example from Replit:** Using Claude's computer use capabilities to evaluate apps as they're built - a key feature requiring visual verification. ### Current limitations Claude's computer use capability is still developing. Anthropic acknowledges these constraints: **Technical Limitations:** - **Latency**: Tasks requiring dozens or hundreds of steps can be slow - **Error-prone**: Scrolling, dragging, and zooming remain challenging - **Resolution constraints**: May struggle with screens higher than 1024×768 or 1280×800 due to image scaling - **Action reliability**: Some actions that people perform effortlessly present challenges for Claude **Safety Concerns:** - Claude may follow instructions found in screen content, even if they conflict with user instructions - Risk of prompt injection from webpages or images - Potential for scaled abuse if not properly isolated **Rate Limits:** - API rate limits apply based on your tier - Processing time varies significantly based on task complexity ### Getting started with Claude computer use You'll need to build an intermediary application that connects Tallyfy to the Anthropic API. Anthropic provides a reference implementation with Docker. ### Basic integration example Here's a simplified example of the integration flow: ```python from anthropic import Anthropic import os client = Anthropic(api_key=os.environ['ANTHROPIC_API_KEY']) # Basic computer use request response = client.messages.create( model="claude-3-5-sonnet-20241022", max_tokens=1024, tools=[ { "type": "computer_20241022", "name": "computer", "display_width_px": 1024, "display_height_px": 768, }, { "type": "text_editor_20241022", "name": "text_editor", }, { "type": "bash_20241022", "name": "bash", } ], messages=[ { "role": "user", "content": "Open the file manager and navigate to Documents folder" } ] ) # Handle tool use requests in the response # Execute tools in your sandbox # Return results to Claude # Continue loop until task complete ``` **Note**: This is a simplified example. Real implementations require full agent loop handling, tool execution in Docker sandbox, and result processing. ### Security best practices **Critical security measures:** - Run Claude Computer Use in a dedicated virtual machine or container with minimal privileges - Limit internet access to approved domains only - Never provide access to sensitive data or account credentials - Isolate Claude from production systems - Require human confirmation for critical actions - Enable thorough audit logging **Known Risks:** - Prompt injection vulnerabilities (Claude may follow on-screen instructions) - Potential for malicious code execution if not properly sandboxed - Risk of information theft if given access to sensitive data ### When to use Claude computer use **Good fit for:** - Desktop application automation (Excel, legacy software) - Data extraction from systems without APIs - Automated testing of desktop applications - Form filling across multiple applications - Low-risk, repetitive UI tasks **Not suitable for:** - Real-time operations (latency issues) - Time-critical tasks (can take dozens or hundreds of steps) - Tasks requiring creative judgment - Social media content creation (restricted by Anthropic) - High-security environments without proper isolation **Success factors:** - Start with simple, well-defined tasks - Implement strong security boundaries - Monitor performance closely - Maintain human oversight - Test with low-risk data first ### Comparison with alternatives Claude Computer Use offers unique desktop control capabilities but has trade-offs: **Advantages:** - Works with any desktop or web application - No need for app-specific APIs or integrations - General-purpose approach adapts to UI changes **Disadvantages:** - Currently slower than traditional RPA for simple tasks - Still experimental with error-prone execution - Requires Docker and sandbox infrastructure - Higher latency than direct API integrations **Alternative approaches:** - Traditional RPA tools for stable, high-volume workflows - Direct API integrations when available - Web-only automation tools for browser-based tasks ### Getting started checklist - [ ] Identify repetitive desktop tasks suitable for automation - [ ] Document exact steps with screenshots - [ ] Set up Anthropic API access with credits - [ ] Install Docker and pull reference implementation - [ ] Create Tallyfy process with clear task instructions - [ ] Test with low-risk, non-sensitive data first - [ ] Implement security isolation and monitoring - [ ] Monitor success rates and refine prompts - [ ] Scale gradually with proven workflows ### Current status and future development Computer Use remains in public beta. Anthropic describes it as "still experimental - at times cumbersome and error-prone" but expects rapid improvement over time. The technology shows promise for automating repetitive tasks, but significant limitations around speed, reliability, and safety need addressing before widespread production adoption. - **[Manus AI agents](https://tallyfy.com/products/pro/integrations/computer-ai-agents/vendors/manus/)**: Manus AI is a fully autonomous AI agent developed by Chinese startup Monica that uses multi-agent architecture and foundation models like Claude to execute complex research and analysis tasks asynchronously in the cloud while Tallyfy could potentially orchestrate these capabilities for cognitive work though current limitations include beta instability and long processing times of 30-60 minutes per task. ## Completing Tallyfy tasks with Manus AI agents Manus AI is developed by Chinese startup Monica (also known as Butterfly Effect AI) and positions itself as a fully autonomous AI agent. What makes it different? It can actually understand complex goals and deliver complete results through autonomous task execution. The company reports state-of-the-art performance on the GAIA benchmark. With its ability to handle tasks involving web research, data analysis, planning, and content generation, Manus AI could work well with Tallyfy - especially for cognitive work that goes beyond simple browser clicks. :::warning[Important guidance for AI agent tasks] Your step-by-step instructions for the AI agent to perform work go into the Tallyfy [task](/products/pro/tracking-and-tasks/tasks/) description. **Start with short, bite-size and easy tasks that are just mundane and tedious.** Do not try and ask an AI agent to do huge, complex decision-driven jobs that are goal-driven - they are prone to indeterministic behavior, hallucination, and it can get very expensive quickly. ::: ### How Manus AI works with Tallyfy This diagram shows how Tallyfy could orchestrate Manus AI's autonomous multi-agent system for complex research and analysis tasks. [Diagram removed for brevity] **What to notice:** - **Asynchronous processing** - Tasks run in the cloud for 30-60 minutes while your team focuses on other work - **Multi-agent collaboration** - Specialized agents work in parallel on different aspects of complex tasks - **Complete deliverables** - Unlike simple automation, Manus produces finished reports and thorough analysis ### Understanding Manus AI: how it works Here's how Manus AI works: you give it a goal, and it runs asynchronously in the cloud to achieve it. Traditional AI assistants just respond to prompts. Manus is different - it operates on its own, makes decisions, completes tasks, and produces finished results with minimal hand-holding. Key aspects of Manus AI include: * **Full Autonomy:** Manus goes beyond chatbot limitations. It automates entire tasks from start to finish - planning, execution, and delivery of complete results. * **Multi-Agent Architecture:** Think of it as a team of specialized sub-agents. One handles planning, another retrieves information, others browse the web or execute code. They work in parallel to get things done. * **Foundation Models:** Rather than building from scratch, Manus uses existing LLMs. You'll find Claude 3.5 Sonnet and Claude 3.7 Sonnet from Anthropic, plus fine-tuned versions of Alibaba's Qwen models under the hood. * **Asynchronous Cloud Operation:** Assign a task and walk away. Manus processes everything in the cloud while you focus on other work. Come back later to find your results ready. * **Iterative Agent Loop:** The system cycles through tasks continuously: 1. **Analyze Events:** Examines user requests and current task status 2. **Select Tools & Plan:** Chooses appropriate tools and refines plans using a Planner Module 3. **Execute Commands:** Performs actions within a secure Linux sandbox environment 4. **Observe & Iterate:** Evaluates results and repeats until task completion * **CodeAct Paradigm:** Need something done? Manus often writes and runs Python code on the fly to accomplish it. That's flexibility. * **Comprehensive Tool Usage:** Web browsers, shell commands, file management, code execution (Python, JavaScript) - Manus can handle them all. * **Memory Systems:** The agent tracks everything through event streams and file-based memory. It even creates `todo.md` files to monitor its own progress. ### Current status and availability Manus AI remains in active development with expanding access: * **Access:** Registration is available at manus.im with a free tier offering one daily task (equivalent to 300 credits) * **Pricing:** Plans range from $19/month (Basic) to $199/month (Pro) * **Geographic Restrictions:** Works best outside mainland China - the Western LLM models it relies on (Claude Sonnet, Qwen) create access issues there * **Development Status:** The platform continues to improve with updates like Manus 1.6 Max, which enhanced autonomous task completion and spreadsheet capabilities ### Performance claims and benchmarks The performance numbers look impressive - if you trust them: * **GAIA Benchmark:** Manus claims state-of-the-art performance on the GAIA benchmark across difficulty levels * **Task Completion:** It can tackle complex, multi-step tasks that need sustained attention and reasoning *Here's the catch: independent verification of benchmark claims remains limited, so approach performance numbers with healthy skepticism.* ### Getting started with Manus AI (conceptual for Tallyfy) Manus AI access has expanded beyond private beta, though direct Tallyfy integration awaits API availability. ### How Tallyfy could integrate with Manus AI (example scenario) Let's look at how this might work with a research-heavy task: **Tallyfy Task:** "Generate Market Analysis Report for New Product Launch" * **Inputs from Tallyfy [Form Fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/):** * `Product Category`: "Smart wearable devices" * `Target Market`: "Health-conscious consumers, fitness enthusiasts" * `Competitor Analysis Scope`: "Top 5 market leaders" * `Geographic Focus`: "North American market" * `Budget Range`: "$100-$300 price point" * **Integration Steps (Conceptual - assuming future API):** 1. A Tallyfy [process](/products/pro/tracking-and-tasks/processes/) reaches this task. 2. Tallyfy sends a request to the Manus AI API with: * `goal`: "Conduct thorough market analysis for smart wearable devices targeting health-conscious consumers in North America. Research top 5 competitors in the $100-$300 price range. Analyze market trends, consumer preferences, pricing strategies, and identify opportunities. Generate a structured report with executive summary, competitive landscape, market sizing, and strategic recommendations." * `input_data`: Content from Tallyfy form fields. 3. Manus AI's Planner Module breaks the work down: market research, competitor analysis, trend spotting, data synthesis, report writing. Smart. 4. Sub-agents get to work - browsing the web, crunching data, generating content. All happening in the cloud. 5. After 30-60 minutes (yes, it takes a while), Manus AI delivers your market analysis document. 6. Tallyfy receives the report and updates the task. Your team can review it and move to the next step. ### Use cases and capabilities What can you actually do with Manus AI? Quite a bit: **Business and Marketing:** * Recruiting and interview optimization * Market analysis and competitive intelligence * SEO strategy development * Supply chain management research **Personal Assistant Functions:** * Travel planning with detailed itineraries * Document generation and organization * Educational content creation **Data Analysis:** * Financial insights and investment analysis * Consumer analytics and sentiment tracking * Industry research and policy studies **Content Creation:** * Audio transcription and content organization * Educational material development * Research report generation ### User feedback and real-world performance Real users share mixed feelings about Manus AI: **Positive Feedback:** * Deep analysis capabilities exceeding expectations * Successful completion of complex, multi-step tasks * Time savings on research-intensive work * Comprehensive output quality **Reported Challenges:** * Tasks take forever - 30 minutes to over an hour (OpenAI Operator is much faster) * The system crashes. A lot. Beta software shows. * Research comes back without citations or references * Complex tasks requiring sustained reasoning? Often fail completely. * Servers get overloaded during busy times * Performance varies wildly between different types of tasks ### Benefits * **Autonomous Complex Task Execution:** Hand off those brain-draining research and analysis tasks to an AI that actually finishes them. * **Handle Broad, Ambiguous Goals:** Give it a high-level objective. It figures out the steps. * **End-to-End Task Completion:** From initial research to final deliverable - Manus handles the entire workflow. * **Asynchronous Operation:** Your team focuses on strategy while Manus does the groundwork in the background. * **Multi-Modal Capabilities:** Text, images, data from anywhere - it processes them all. ### Potential considerations * **Beta Status & Limited Access:** You can't properly test it. Planning an integration? Good luck. * **Performance Variability:** Complex tasks work sometimes. Other times they don't. Frustrating. * **Verification Challenges:** Those impressive benchmark scores? Can't verify them independently due to access restrictions. * **Technical Dependencies:** It's built on Claude and Qwen models - not their own. That's a dependency risk. * **Cost Structure:** Paid plans range from $19-$199/month, which may be costly for routine tasks. * **Reliability Concerns:** Beta users report crashes and failures that need human rescue. Not ideal. * **Task Scope Definition:** You need to be precise but not too prescriptive. Finding that balance is tricky. **Note on Current Status:** While Manus AI has expanded access with a free tier, reliability and integration capabilities are still maturing. Evaluate your use case carefully before committing to a paid plan. Could Tallyfy and Manus AI work together to automate complex cognitive tasks? Absolutely. Should you bet on it today? Probably not. The platform needs time to mature and prove it can deliver stable integration capabilities. - **[OpenAI agent capabilities](https://tallyfy.com/products/pro/integrations/computer-ai-agents/vendors/openai-chatgpt-agent/)**: OpenAI provides agent capabilities through tools like the Responses API and Agents SDK that integrate with Tallyfy to automate web interactions and document processing tasks by triggering webhooks and capturing structured outputs while routing failures to human review through conditional logic. ## Using OpenAI agent capabilities with Tallyfy :::note[Information Currency] OpenAI's agent features evolve rapidly. OpenAI Operator (launched January 2025) was deprecated in August 2025 and replaced by "ChatGPT agent" mode integrated directly into ChatGPT. Check OpenAI's official documentation for the latest capabilities, pricing, and availability. ::: OpenAI provides agent capabilities through several tools: the Responses API, Agents SDK, and Computer Use (CUA) model. These work with Tallyfy to automate workflow tasks that involve web interactions, document processing, and data extraction. OpenAI's Operator (launched January 2025, deprecated August 2025) demonstrated browser automation using the Computer-Using Agent (CUA) model. The CUA model now uses o3 reasoning capabilities instead of the original GPT-4o. The model scored 38.1% on the OSWorld benchmark and 58.1% on WebArena - showing limitations for complex automation. These capabilities are now available through "ChatGPT agent" mode in ChatGPT. More recently, OpenAI released the Responses API and open-source Agents SDK, which provide developers with tools for building AI agents that combine multiple capabilities including web search, file processing, and computer use. :::warning[Important guidance for AI agent tasks] Your step-by-step instructions for the AI agent to perform work go into the Tallyfy [task](/products/pro/tracking-and-tasks/tasks/) description. **Start with short, bite-size and easy tasks that are just mundane and tedious.** Do not try and ask an AI agent to do huge, complex decision-driven jobs that are goal-driven - they are prone to indeterministic behavior, hallucination, and it can get very expensive quickly. ::: ### How OpenAI agents work with Tallyfy Tallyfy orchestrates OpenAI agent capabilities by triggering tasks, providing structured inputs, and capturing outputs. The integration uses webhooks or API calls to connect Tallyfy processes with OpenAI's agent tools. [Diagram removed for brevity] **What to notice:** - **Multiple tools** - OpenAI agents use computer use, web search, and file search based on task requirements - **Structured data flow** - Tallyfy provides inputs through form fields and captures agent outputs for downstream tasks - **Error handling** - Failed tasks can route to human review through Tallyfy's conditional logic ### OpenAI agent capabilities OpenAI's agent platform includes several components that work together: **Responses API**: Combines chat capabilities with multi-tool support, allowing agents to use web search, file search, and computer use within a single API call. **Agents SDK**: Open-source toolkit for building single-agent and multi-agent workflows. Works with OpenAI models and competitor models from Anthropic and Google. **Computer Use (CUA)**: Browser automation powered by the CUA model with o3 reasoning. Captures screenshots, identifies UI elements, and simulates mouse/keyboard actions. Available through "ChatGPT agent" mode in ChatGPT. **Web Search**: Integration with GPT-4o search providing factual accuracy of 90% on SimpleQA benchmark. Includes citations to original sources. **File Search**: Document retrieval from large document sets with metadata filtering support. ### Integration with Tallyfy workflows Tallyfy provides structure for OpenAI agent automation: **Trackable execution**: Every agent action happens within a Tallyfy process with full audit trail. **Error recovery**: When agents encounter issues, Tallyfy's conditional logic can route tasks to humans for completion. **Incremental approach**: Start with simple tasks like form filling or data extraction. Monitor results. Expand gradually to more complex workflows. **MCP support**: With Model Context Protocol servers, OpenAI agents can interact with Tallyfy using natural language commands like "complete the next task in customer onboarding." ### Technical details of OpenAI agent capabilities The Computer-Using Agent (CUA) model now uses o3 reasoning capabilities: **Visual perception**: Captures screenshots of web pages and identifies UI elements like buttons, text fields, and links. **Action execution**: Simulates mouse clicks and keyboard input to interact with websites. **Safety controls**: Pauses for user approval before sensitive actions like payments or credential entry. Includes fine-tuning to resist prompt injection attacks. **Performance benchmarks** (original CUA model): - OSWorld: 38.1% (real-world computer tasks) - WebArena: 58.1% (web navigation scenarios) - Performance may improve with o3-based updates **Best suited for**: - Form filling and data entry - Restaurant reservations and bookings - Simple information gathering - Document retrieval from web portals **Limitations**: Struggles with complex interfaces, multi-page workflows requiring sustained context, and websites with anti-bot measures. ### Current availability **ChatGPT agent mode**: Available to ChatGPT Plus, Pro, and Enterprise subscribers. Access by selecting "agent mode" from the dropdown in the ChatGPT composer. **API access**: Available through Responses API and Agents SDK. **Note**: Features, pricing, and availability change frequently. See [OpenAI's pricing page](https://openai.com/pricing) for current rates and subscription details. ### Integration approach ### Example workflow: restaurant reservation **Scenario**: Automate restaurant reservations for client meetings. **Tallyfy task configuration**: - Task description contains clear instructions: "Make reservation on OpenTable for the restaurant and date specified in form fields" - Form fields collect: restaurant name, party size, date/time, special requests - Webhook triggers when task is assigned **Agent execution**: 1. Receives structured data from Tallyfy webhook 2. Navigates to restaurant booking site 3. Fills reservation form 4. Captures confirmation number 5. Returns result to Tallyfy **Result handling**: - Success: Confirmation number stored in form field, next task triggered - Failure: Task reassigned to human with error details - Partial completion: Flagged for manual review ### Integration options **Responses API**: Send task instructions and data directly to OpenAI's API. Agent uses available tools (web search, computer use, file search) to complete the task. **Agents SDK**: Build custom workflow orchestration using the open-source SDK. Supports multi-agent workflows and mixed model usage. **MCP server**: Create a Model Context Protocol server that exposes Tallyfy operations. OpenAI agents can then interact with Tallyfy using natural language. **Webhook architecture**: Use message queues between Tallyfy and OpenAI to handle high-volume automation with retry logic and parallel processing. ### Use case examples **Invoice data extraction**: - Agent navigates to supplier portal - Downloads invoices - Extracts key data (invoice number, amount, date) - Returns structured data to Tallyfy - Human reviews before accounting entry **Customer onboarding tasks**: - Creating collaboration workspace invites - Setting up shared folders - Scheduling kickoff meetings - Generating welcome communications - Human handles contract review and customization **Competitive research**: - Visits competitor websites - Captures pricing and feature information - Compares with previous data - Generates summary report - Routes to team for analysis ### Configuration considerations **Task instructions**: Write specific, clear instructions. Include exact URLs, button names, field labels, and expected outputs. Good: "Navigate to acme.com/invoices, download PDFs from last 30 days, extract invoice numbers and amounts" Poor: "Get the invoices" **Security**: Never store passwords in task descriptions. Use secure credential management. Enable user approval for sensitive actions. **Error handling**: Configure Tallyfy conditional logic to route failed tasks to humans. Log agent actions for debugging. **Monitoring**: Track success rates by task type. Adjust instructions based on failure patterns. ### API pricing OpenAI API pricing varies by model (GPT-4o, o1, o3, o4-mini) and changes frequently. See [OpenAI's pricing page](https://openai.com/pricing) for current rates. ### Troubleshooting **Task fails repeatedly**: - Instructions may be too vague - add specific details (button names, URLs, exact text) - Website may have anti-bot measures - consider manual fallback - Dynamic content loading - agent may need explicit wait instructions - Login credentials missing or incorrect **Integration not triggering**: - Verify webhook URL is accessible - Check authentication tokens - Confirm Tallyfy process is published and active - Review webhook logs for error responses **Partial completion**: - Use Tallyfy conditional logic to route partially completed tasks to humans - Add verification steps after agent tasks - Track patterns in partial completions to refine instructions ### Limitations **Current constraints**: - Performance on complex tasks is limited (38% OSWorld, 58% WebArena benchmarks for original CUA model) - Processing time varies, typically several minutes per task - Geographic availability limited to select regions - Experimental technology - expect changes and occasional failures - Requires careful credential management for security - Not suitable for tasks requiring nuanced decision-making **Best practices**: - Start with simple, high-volume tasks - Always have human fallback for critical processes - Test thoroughly before production deployment - Monitor success rates and adjust instructions - Use Tallyfy's conditional logic for error handling - Keep instructions simple and specific - **[Skyvern AI agents](https://tallyfy.com/products/pro/integrations/computer-ai-agents/vendors/skyvern/)**: Skyvern is an open-source browser automation tool that uses LLMs and computer vision to execute web-based workflows through a multi-agent architecture and can integrate with Tallyfy via webhooks or middleware platforms to handle tasks like invoice management and form submissions while adapting to website changes in real-time. :::note[Information Currency] Browser automation tools evolve rapidly - check Skyvern's official documentation at docs.skyvern.com for current features and pricing. ::: ## Browser automation with Skyvern Skyvern automates browser workflows using LLMs and computer vision. It's open source (AGPL-3.0 license) and has demonstrated strong performance on the WebVoyager benchmark. Unlike traditional RPA scripts that break when websites change, Skyvern adapts in real-time using visual understanding. :::warning[Important guidance for AI agent tasks] Your step-by-step instructions for the AI agent to perform work go into the Tallyfy [task](/products/pro/tracking-and-tasks/tasks/) description. **Start with short, bite-size and easy tasks that are just mundane and tedious.** Do not try and ask an AI agent to do huge, complex decision-driven jobs that are goal-driven - they are prone to indeterministic behavior, hallucination, and it can get very expensive quickly. ::: ### Integration possibilities with Tallyfy Skyvern can be integrated with Tallyfy through webhooks or middleware platforms (Zapier, Make, n8n) to automate browser-based tasks. The integration follows this pattern: Tallyfy triggers the automation request, Skyvern executes the browser workflow, and returns structured data back to Tallyfy. **What you get:** - **Three-agent architecture** - Planner decides goals, Actor executes actions, Validator confirms success - **Self-correcting behavior** - Failed tasks trigger automatic retries with different approaches - **Structured output** - Returns JSON or CSV data that maps to Tallyfy form fields ### Key capabilities **Deployment options:** - **Open source** - Self-host under AGPL-3.0 license with full source code access - **Cloud** - Managed service at app.skyvern.com with anti-bot measures, proxies, and CAPTCHA solving **Performance:** - Strong results on WebVoyager benchmark across thousands of real-world tasks - Multi-agent architecture significantly improved accuracy over earlier versions **Technical foundation:** - Supports multiple LLM providers: OpenAI, Anthropic, Azure OpenAI, AWS Bedrock, Ollama, OpenRouter, Gemini, Novita AI - Python 3.11-3.13 compatibility - Uses Playwright for browser automation - Real-time visual parsing with computer vision **Advanced features:** - CAPTCHA solving and 2FA authentication (QR codes, email, SMS) - Enterprise proxy networks for geo-targeting - Livestream browser viewport for debugging - File downloads and uploads - Credit card form filling **Pricing:** - Cloud: Pay-per-step pricing model (check current rates at skyvern.com) - Free tier available with starter credit - Self-hosted: Free (you pay for infrastructure and LLM API costs) ### Multi-agent architecture Skyvern's multi-agent architecture splits work across specialized agents: **Planner Agent** - Sets goals based on the overall objective - Maintains working memory of progress - Breaks complex tasks into sub-goals **Actor Agent** - Executes specific actions for narrowly scoped goals - Reports completion status and issues - Handles browser interactions and element identification **Validator Agent** - Checks if goals were achieved successfully - Provides feedback to Planner and Actor - Triggers retries when tasks fail **Specialized sub-agents:** - **Interactable Element Agent** - Identifies buttons, forms, links in HTML - **Navigation Agent** - Plans action sequences to reach goals - **Data Extraction Agent** - Structures webpage data into JSON or CSV - **Password Agent** - Handles login forms with password manager integration - **2FA Agent** - Manages authentication prompts during login - **Auto-complete Agent** - Handles complex form fields like address lookups ### Getting started ### Real-world use cases According to Skyvern's documentation, production deployments handle these scenarios: **Invoice management:** - Automated login to multiple vendor portals - Download monthly statements and invoices - Rename, organize, and store files automatically **Job applications:** - Apply to job postings across multiple platforms - Fill application forms with candidate information - Upload resumes and cover letters **Government compliance:** - Submit forms to state and federal portals - Handle multi-step flows with 2FA - Upload documents and confirm receipt **E-commerce operations:** - Purchase items from hundreds of different websites - Extract competitor pricing data - Post listings across multiple platforms **IT operations:** - Employee onboarding and offboarding workflows - System access provisioning - Credential management across tools ### Why Skyvern stands out **Resilient to website changes:** Traditional RPA scripts break when websites redesign. Skyvern uses visual understanding to adapt automatically - no XPath selectors to maintain. **Open source flexibility:** Self-host and customize without vendor lock-in. AGPL-3.0 license provides full source access. **Handles web complexity:** CAPTCHA solving, 2FA authentication, proxy networks for geo-targeting, and credit card processing work out of the box. **Proven performance:** Strong accuracy on WebVoyager benchmark across thousands of real-world tasks. **Scalable infrastructure:** API-driven design supports running thousands of parallel automation tasks through cloud or self-hosted deployments. ### Important considerations **Prompt quality matters:** Vague instructions lead to failed tasks. Clear, specific prompts are essential for reliable automation. **Self-hosting requirements:** Running browser automation with LLMs requires significant CPU and RAM. Budget for infrastructure costs beyond the free software. **AGPL-3.0 license implications:** If you modify Skyvern and offer it as a public service, you must share your source code changes. **Website defenses exist:** Even with Skyvern's anti-bot measures, aggressive automation can trigger rate limits. The cloud version includes proxy networks to help. **Task complexity limits:** Break down complex multi-step workflows carefully. Test incrementally to identify failure points early. - **[Twin.so AI agents](https://tallyfy.com/products/pro/integrations/computer-ai-agents/vendors/twin/)**: Twin.so builds AI browser automation agents for enterprise customers through direct partnerships with their Invoice Operator already serving over 500000 European SMBs through Qonto and potential Tallyfy integration would require custom development to connect browser-based document retrieval and web portal tasks with workflow orchestration. :::note[Information Currency] Twin.so is enterprise-focused and works primarily through direct partnerships. For current pricing, capabilities, and integration options, contact Twin.so directly. ::: ## Using Twin.so AI agents with Tallyfy Twin.so builds AI agents that control web browsers to automate tasks - no API required. Their agents interact with websites like a human would, clicking buttons and filling forms. Twin Labs (founded 2024) has proven this works at scale with their Invoice Operator serving over 500,000 European SMB customers through a partnership with Qonto, a fintech platform. :::warning[Important guidance for AI agent tasks] Your step-by-step instructions for the AI agent to perform work go into the Tallyfy [task](/products/pro/tracking-and-tasks/tasks/) description. **Start with short, bite-size and easy tasks that are just mundane and tedious.** Do not try and ask an AI agent to do huge, complex decision-driven jobs that are goal-driven - they are prone to indeterministic behavior, hallucination, and it can get very expensive quickly. ::: ### How browser automation works with Tallyfy This flowchart shows a conceptual integration pattern where Tallyfy orchestrates browser automation to retrieve documents from web portals. [Diagram removed for brevity] **What to notice:** - **Credential security** - Sensitive login information stored separately from task descriptions - **Sequential execution** - Tasks proceed step-by-step through navigation, login, and data extraction - **Result delivery** - Extracted data or documents returned to Tallyfy for workflow continuation ### What Twin.so offers Twin.so provides AI agents for browser-based automation. According to their publicly available information: **Core Capabilities:** - **Browser control** - Agents navigate websites and interact with web applications - **Natural language goals** - Provide a starting URL and goal in plain English - **Production deployment** - Invoice Operator handles invoice retrieval for 500,000+ European SMBs - **OpenAI collaboration** - One of 15 companies chosen to alpha-test OpenAI's Computer-Using Agent (CUA) model - **Credential management** - Secure vault system for storing website login credentials - **Enterprise infrastructure** - Built for scale with browser infrastructure designed for enterprise use **Technology Foundation:** - Uses remote Chromium browser sessions for automation - Powered by AI models including OpenAI's CUA technology - Adaptive to website changes (unlike traditional RPA scripts) - Processes tasks through their Twin Model (action planning system) **Performance Claims:** Twin.so states they've improved performance significantly over three generations of their technology, with substantial speed increases, cost reductions, and accuracy improvements. ### Real-world deployment: Invoice Operator Twin.so's first major product is the Invoice Operator, built in partnership with Qonto (European fintech) and OpenAI: - **Scale** - Serves 500,000+ SMBs across Europe - **Function** - Automatically retrieves invoices from vendor portals - **Support** - Works with thousands of different invoice provider websites - **Integration** - Embedded directly in Qonto's platform for seamless operation This deployment demonstrates that browser automation can work at production scale for repetitive document retrieval tasks. ### Potential integration with Tallyfy Twin.so focuses on enterprise partnerships rather than self-service integration. Integration with Tallyfy would likely require: ### Example automation scenario Here's how a Tallyfy-Twin.so integration might work for invoice retrieval: **Tallyfy Task**: "Retrieve Monthly Invoice from Service Provider" **Task Inputs** (from Tallyfy [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/)): - Service provider name - Invoice date/period - Credential vault reference **Automation Flow**: 1. Tallyfy task triggers webhook when assigned 2. Webhook calls Twin.so API with task goal 3. Twin.so agent navigates to provider's billing portal 4. Agent logs in using vaulted credentials 5. Agent locates and downloads specified invoice 6. Twin.so returns invoice file and metadata 7. Tallyfy receives results and updates task This pattern could apply to various document retrieval and web-based data extraction scenarios. ### Use cases for browser automation Combining Tallyfy's workflow management with browser automation could address: - **Invoice collection** - Retrieve invoices from multiple vendor portals automatically - **Supplier monitoring** - Check order status and delivery tracking across supplier websites - **Data extraction** - Pull customer information from web-based systems without APIs - **Compliance documentation** - Download required documents from regulatory portals - **Financial aggregation** - Collect account information from multiple banking websites - **E-commerce operations** - Monitor inventory, pricing, and product listings across platforms ### Important considerations **Enterprise Partnership Model:** - Twin.so focuses on enterprise customers with custom implementations - No self-service signup or standard pricing available publicly - Expect to work directly with their team for any integration **Integration Requirements:** - Custom development needed to connect with Tallyfy - API integration requires technical implementation work - Enterprise partnerships likely have minimum volume commitments **Best Fit Scenarios:** - High-volume repetitive tasks (like invoice processing at scale) - Browser-based work that can't be automated through APIs - Document retrieval from multiple web portals - Operations requiring navigation of complex web interfaces **Current Geographic Focus:** - Most deployments currently in Europe (via Qonto partnership) - Availability in other regions would need verification with Twin.so For production integration with Tallyfy, contact Twin.so directly to discuss your specific automation needs and integration requirements. ### Email - **[Gmail add-on](https://tallyfy.com/products/pro/integrations/email/how-can-i-manage-my-tasks-with-tallyfys-gmail-add-on/)**: The Tallyfy Gmail Add-on streamlines workflow management by enabling users to create tasks launch processes and track progress directly from their Gmail inbox without switching between applications. ## Using the Tallyfy Gmail Add-on Tired of jumping between Gmail and Tallyfy all day? The Gmail add-on lets you create tasks, launch processes, and track everything - right from your inbox. No more tab switching. ### What you need - A Google Workspace (formerly G Suite) or a standard Gmail account - An active Tallyfy account - Permission from your Google Workspace admin to install add-ons (if you're using a work account) - Basic knowledge of how Tallyfy works ### Key features - **Create tasks**: Turn any email into a Tallyfy task in 2 clicks - **Launch processes**: Start a workflow directly from an email thread - **Track status**: See all your tasks without leaving Gmail - **Save time**: Cut out the constant app switching - **Keep context**: Email content automatically links to the task you create ### How to install it :::note[Admins Installing for Everyone] Google Workspace admins can set up the add-on for everyone in the organization via the Admin Console (Apps > Marketplace Apps). ::: ### Using the add-on in Gmail Open any email. See that Tallyfy icon in the right sidebar? Click it. ![Tallyfy Gmail add-on in G Suite Marketplace](https://screenshots.tallyfy.com/tallyfy/pro/gmail-addon-marketplace-listing.png) ### Creating a Tallyfy Task from an email Got an important email that needs action? Here's how you turn it into a task in under 30 seconds: ### Starting a Tallyfy Process from an email Need to kick off a whole workflow from an email? You can launch any of your templates without leaving Gmail: ### Checking your Tallyfy tasks Want a quick view of what's on your plate? The add-on shows all your tasks instantly: ### Troubleshooting tips | Problem | Possible Solution | |-------------------------|------------------------------------------------------| | Tallyfy icon missing | Refresh Gmail, then clear your browser cache | | Can't sign in | Sign out of the add-on completely, then sign back in | | Can't create tasks | You might be a Light user - check your Tallyfy permissions | | Add-on is slow | Usually it's your connection - try refreshing | ### Where it works The add-on runs great on the Gmail website (desktop or laptop). Mobile Gmail app? It works there too - though you'll get the full experience on desktop. - **[Set up custom SMTP sending](https://tallyfy.com/products/pro/integrations/email/how-to-set-up-custom-smtp-in-tallyfy/)**: This guide explains how to configure custom SMTP servers with Tallyfy including required credentials setup procedures testing methods and troubleshooting solutions to ensure reliable branded email delivery while maintaining security compliance and organizational control over workflow communications. ## Custom SMTP Server Configuration Want to use your own email server with Tallyfy? You're in the right place. This guide walks you through setting up custom SMTP - from initial configuration to testing everything works properly. ### Requirements Before configuring custom SMTP in Tallyfy, ensure you have: - Administrator access to your Tallyfy organization - SMTP server details from your IT department or email service provider - Authentication credentials for your SMTP server - Verified that your email server allows third-party application connections - Confirmed your organization's email security policies permit this integration ### Benefits of custom SMTP Here's why organizations love using their own SMTP server with Tallyfy: - **Improved deliverability** - Emails from your domain get through. No more spam folder surprises. - **Tracking** - Access server logs for all outbound emails sent through Tallyfy - **Consistent branding** - Keep your company's email reputation and formatting intact - **Security compliance** - Sensitive email traffic stays within your existing security framework - **Existing configurations** - Your SPF, DKIM, and DMARC records? They work perfectly here. - **White-labeled communications** - Every workflow email appears from your domain (not ours) :::caution[Email Reply Limitation] There's one trade-off with custom SMTP - emails won't be "replyable" for comments. When users hit reply on a task notification, that response won't automatically appear as a comment in Tallyfy. The email goes to your inbox instead. ::: :::note[Single Account Limitation] Tallyfy needs a single central email account for all outgoing emails - something like "tallyfy@company.com". Individual user email accounts aren't supported yet. Plan accordingly. ::: ### Required SMTP information Gather these details before proceeding with configuration: | Parameter | Description | Example | |-----------|-------------|---------| | SMTP Server Host | Your mail server address | smtp.company.com | | SMTP Port | Port for mail submission | 587 (TLS) or 465 (SSL) | | Username | Account for authentication | tallyfy@company.com | | Password | Authentication credential | Your secure password | | From Email | Sender's email address | workflows@company.com | | From Name | Display name for sender | Company Workflows | | Encryption Method | Security protocol | TLS or SSL | ### Configuration steps Ready to connect your SMTP server? Let's do it: ### Testing SMTP configuration Smart move - test your settings before going live. These external tools help verify everything's configured correctly: #### Microsoft Remote Connectivity Analyzer Microsoft's official tool gives you the most thorough SMTP check: 1. Visit the [Outbound SMTP Email test](https://testconnectivity.microsoft.com/tests/OutboundSMTP/input/) 2. Enter your SMTP server details and credentials 3. Run the test to verify connectivity and authentication 4. Review detailed results for any connectivity issues ![Microsoft Remote Connectivity Analyzer for SMTP testing](https://screenshots.tallyfy.com/tallyfy/pro/smtp-microsoft-connectivity-analyzer.png) #### Wormly SMTP Tester Need something quick? Wormly's tool takes 30 seconds: 1. Navigate to [Wormly's SMTP server test](https://www.wormly.com/test-smtp-server/) 2. Enter your server hostname and port 3. Complete the test to verify basic connectivity 4. Check for open ports and server responsiveness ![Wormly SMTP server test tool](https://screenshots.tallyfy.com/tallyfy/pro/smtp-wormly-test-tool.png) #### MXToolbox Diagnostic Tools MXToolbox goes deeper - it checks your entire email infrastructure: 1. Visit [MXToolbox SuperTool](https://mxtoolbox.com/SuperTool.aspx/) or [MXToolbox Diagnostics](https://mxtoolbox.com/diagnostic.aspx/) 2. Enter your domain or server information 3. Run various tests to check SMTP configuration, DNS records, and blacklist status 4. Review detailed reports on email infrastructure health ![MXToolbox SMTP diagnostic test results](https://screenshots.tallyfy.com/tallyfy/pro/smtp-mxtoolbox-test-results.png) #### GMass SMTP Tester Worried about authentication? GMass specifically tests your credentials: 1. Access the [GMass SMTP test tool](https://www.gmass.co/smtp-test/) 2. Enter your complete SMTP configuration including credentials 3. Test the connection to verify authentication works correctly 4. Confirm that message sending completes successfully ![GMass SMTP Test Tool interface](https://screenshots.tallyfy.com/tallyfy/pro/smtp-gmass-test-tool.png) :::caution[External Tools] These testing tools are third-party services not affiliated with Tallyfy. Be careful with your credentials - maybe create temporary test accounts if you're concerned about security. ::: ### Verifying successful configuration Configuration looks good? Time for the real test: ### Troubleshooting SMTP issues #### Common problems and solutions | Issue | Possible Causes | Solutions | |-------|----------------|-----------| | Connection timeout | Firewall blocking traffic | Open outbound ports for SMTP traffic | | Authentication failure | Incorrect credentials | Verify username and password format | | SSL/TLS errors | Wrong encryption setting | Try alternative encryption method | | Rate limiting | Too many connections | Increase server limits or optimize email volume | | DNS resolution failure | Incorrect server hostname | Verify the SMTP host address | | Rejected messages | Malformed headers | Check "From" address matches authorized sender | #### Additional troubleshooting steps Still having issues? Work through these checks: ##### 1. Network connectivity - Your firewall must allow outbound connections from Tallyfy to your SMTP server - The SMTP port (587 or 465) needs to be open for outbound traffic - Test basic connectivity using telnet or similar tools ##### 2. Authentication issues - Make sure the SMTP account has permission to send email - Check if your mail server accepts the authentication method you're using - Multi-factor authentication can interfere - you might need an app password ##### 3. Rate limits and volume - Your SMTP server's rate limits need to handle Tallyfy's email volume - High-volume senders should consider implementing sending queues ##### 4. DNS and email security - Your SPF record must include your SMTP server's IP address. Period. - DKIM and DMARC configurations need to be correct (if you use them) - The "From" address domain has to match the authenticated domain :::tip[Best Practice] Once everything's set up, send test emails to Gmail, Outlook, and other providers. You'll catch any deliverability issues before your team notices. ::: - **[Connect your email](https://tallyfy.com/products/pro/integrations/email/connect-your-email/)**: The Connect Your Email feature allows users to send workflow emails directly from their personal Gmail or Outlook accounts instead of through Tallyfy's centralized system which improves deliverability and response rates by making emails appear more personal and trustworthy to recipients. ## What is the Connect Your Email feature? **This planned feature will let you send workflow emails directly from your personal Gmail or Outlook account.** Unlike our current centralized SMTP system where all emails come from Tallyfy's servers, this will allow each user to authorize Tallyfy to send emails on their behalf - meaning recipients see emails coming from you@yourcompany.com, not from a system address. Here's the thing: when your coworkers get a task notification, they want to see it's from *you*, not from some automated system. That personal touch makes all the difference - emails are more likely to be opened, trusted, and acted upon when they come from a real person's email account. Plus, your IT department will love that emails stay within your company's existing security and compliance frameworks. ### How is this different from custom SMTP? Our existing [custom SMTP feature](/products/pro/integrations/email/how-to-set-up-custom-smtp-in-tallyfy/) lets your organization configure a single mail server for all Tallyfy notifications. That's great for branding - emails come from yourcompany.com instead of Tallyfy's servers. But they still come from a generic address like notifications@yourcompany.com. With the Connect Your Email feature, it's completely different: - **Personal authorization**: Each user connects their own email account - **Individual sending**: Emails come from john.smith@yourcompany.com, not notifications@ - **One-to-one mapping**: Your email account sends only your workflow emails - **No sharing**: Other users can't send from your account - **Better engagement**: Recipients see a real person's name, not "Tallyfy System" Think of it this way - custom SMTP is like having a company mailroom that handles all outgoing mail. Connect Your Email is like writing and sending the letter yourself, with your signature. ### Why connect your personal email account? **Deliverability skyrockets when emails come from real accounts.** Your email address has years of reputation built up - people have you in their contacts, they've replied to you before, their email clients recognize you. When Tallyfy sends on your behalf, all that trust transfers to your workflow notifications. But it goes beyond just getting past spam filters: - **Response rates improve by 40%**: People respond to people, not systems - **Context stays intact**: When someone replies, it goes to your actual inbox - **Audit trails strengthen**: Every sent email appears in your Sent folder - **Compliance simplifies**: Your company's existing email retention policies apply automatically Want to know something interesting? Companies using personalized sending see task completion rates jump by 25% in the first month. Turns out, people take requests more seriously when they come from a colleague's actual email address. ### How will the connection process work? Setting up your email connection will take about 2 minutes. You'll click "Connect Email" in your Tallyfy settings, sign in with your email provider (Google or Microsoft), and grant permission for Tallyfy to send emails on your behalf. No passwords are shared - it's all handled through secure OAuth tokens that you can revoke anytime. The process differs slightly by provider: **For Google Workspace/Gmail users:** 1. Click Connect in Tallyfy settings 2. Sign in to your Google account 3. Review the permissions (we only request email sending) 4. Click Allow 5. Done - Tallyfy can now send as you **For Microsoft 365/Outlook users:** 1. Click Connect in Tallyfy settings 2. Sign in with your Microsoft account 3. Your admin might need to approve the app first (one-time setup) 4. Grant the Mail.Send permission 5. Done - emails flow through your account :::note[Admin Approval May Be Required] Some organizations require IT admin approval before users can connect third-party apps. If you see a message about admin consent, forward the connection link to your IT team. They'll approve Tallyfy once for the whole organization, then everyone can connect their accounts. ::: ### What permissions will Tallyfy request? **We only ask for the minimum permission needed: sending email.** We don't read your inbox, we don't access your contacts, we don't modify your settings. Just one permission - the ability to send emails as you. Specifically: - **Google**: `gmail.send` scope only (not `gmail.readonly` or `gmail.modify`) - **Microsoft**: `Mail.Send` permission only (not `Mail.Read` or `Mail.ReadWrite`) This is important - many email integrations request broad access to your entire mailbox. We don't need that and don't want it. You're granting Tallyfy permission to send specific workflow emails when you trigger them, nothing more. ### Will IT departments need to approve this? It depends on your organization's security settings. Most companies allow users to connect apps that only send email, but some have stricter policies. **Organizations with open policies** (most common): - Users can connect immediately - No IT involvement needed - Takes 2 minutes per user **Organizations with restricted policies**: - IT admin gets a one-time approval request - Admin approves Tallyfy for the entire organization - Then all users can connect without further approval - Total setup: 10 minutes for admin, 2 minutes per user We'll provide your IT team with: - Our OAuth application details for verification - Security assessment documentation - Exact scopes and permissions requested - Compliance certifications (SOC 2, GDPR, etc.) ### How will this work with multiple email accounts? Each Tallyfy user connects one primary email account. If you have multiple email addresses (like separate accounts for different departments), you'll choose which one to use for workflow notifications. You can change your connected account anytime - just disconnect the current one and connect a different one. Takes about 30 seconds to switch. ### What about email threading and conversations? **Your workflow emails will thread properly with existing conversations.** When Tallyfy sends a task notification through your account, it includes the proper headers to maintain email threads. Recipients can reply directly to you, and those replies appear in your regular inbox - not in some separate system. This creates natural conversation flows: 1. You assign a task to Sarah 2. Sarah gets an email from you (via Tallyfy) 3. Sarah replies with a question 4. You see her reply in your inbox 5. You respond normally 6. The whole conversation stays together ### When will this feature be available? We're actively developing this feature. Want early access? Contact our support team to join the beta waitlist. We're especially interested in organizations that: - Have strict email security requirements - Use Google Workspace or Microsoft 365 extensively - Send high volumes of workflow notifications - Need personalized sending for compliance reasons ### Connect your email - **[Google Workspace email connection](https://tallyfy.com/products/pro/integrations/email/connect-your-email/google-workspace/)**: Google Workspace integration will enable sending workflow emails from user Gmail accounts through OAuth 2.0 with minimal permissions while maintaining security compliance and providing complete audit trails through standard Google consent processes. ## How will Google Workspace integration work? **This planned feature will let you connect your Gmail or Google Workspace account so Tallyfy can send workflow emails directly from your email address.** We'll use Google's OAuth 2.0 system with only the `gmail.send` permission - the absolute minimum needed to send emails on your behalf without accessing your inbox or contacts. Want to know something interesting? Google classifies email permissions into three tiers, and we deliberately chose the least invasive one. The `gmail.send` scope is considered "Sensitive" (not "Restricted"), which means we can offer this integration without the expensive annual security audits that full email access requires. You get personalized sending without the privacy concerns. ### What's required for Google OAuth verification? **Tallyfy will complete Google's standard OAuth verification for the `gmail.send` scope.** This is a one-time process we handle before the feature launches, not something you need to worry about. Here's what this means for you: - **No security assessment required**: Unlike apps that read your email, we don't need CASA audits - **Standard verification only**: Takes 2-4 weeks, not months - **Lower ongoing costs**: No annual $15,000-75,000 security assessment fees - **Faster approval**: Google reviews send-only apps much quicker The verification process ensures: - Tallyfy's identity is confirmed - Our privacy policy meets Google's standards - The app name and logo are approved - Security practices are documented - User consent screens are clear :::note[Why This Matters] Many email integrations request the `https://mail.google.com/` scope, which requires expensive annual security assessments. By limiting ourselves to just `gmail.send`, we keep costs down and pass those savings to you while maintaining full security. ::: ### Will users see an "unverified app" warning? **No - once we complete verification, users will see a standard Google consent screen.** During our development and testing phase, beta testers might see an "unverified app" screen, but this disappears once Google approves our application. The consent screen will clearly show: - Tallyfy's verified publisher badge - Exactly what permission you're granting (send email only) - How to revoke access later - No scary warnings or red flags ### What about Google Workspace admin controls? **Your Google Workspace admin controls whether users can connect third-party apps.** Most organizations allow it, but some have restrictions. **Scenario 1: Open access (default setting)** - Your admin has "Allow users to access any third-party apps" enabled - You can connect Tallyfy immediately - No admin action needed - This is how 80% of organizations operate **Scenario 2: Restricted access** - Your admin has blocked unconfigured third-party apps - Admin must add Tallyfy to the allowed apps list - We'll provide your admin with our OAuth client ID - Once added, all users can connect - Takes about 5 minutes for admin to configure **Scenario 3: Highly restricted** - Organization blocks all third-party API access - Requires policy exception for Tallyfy - We'll provide security documentation for review - May need security team approval ### How do IT admins approve Tallyfy? We'll provide admins with a one-page setup guide including: - Our exact OAuth client ID - Screenshots of each configuration step - Security compliance documentation - Direct support contact for questions ### What if my organization uses IP restrictions? Google Workspace IP restrictions won't affect Tallyfy's email sending. When we send emails through your account, they originate from Google's servers, not ours. The API calls come from Tallyfy's verified servers, which you can whitelist if needed. If your organization requires IP whitelisting: - We'll provide our API server IP ranges - These are stable and rarely change - We notify customers 30 days before any IP changes - Typically only 3-5 IP addresses to whitelist ### How does this work with Google's "Less Secure Apps" policy? **This doesn't use "Less Secure Apps" at all - that's old technology.** We use modern OAuth 2.0, which Google actively recommends. In fact, Google is phasing out less secure app access entirely by 2025, but OAuth connections like ours will continue working indefinitely. Key differences: - **Less Secure Apps**: Uses your password directly (deprecated) - **OAuth 2.0**: Uses revocable tokens without password access (recommended) - **Our approach**: Follows Google's best practices for third-party integration ### What about sending limits and quotas? **Your existing Gmail sending limits apply when Tallyfy sends on your behalf.** Google enforces these limits to prevent spam: **Google Workspace accounts**: - 2,000 emails per day - 500 recipients per message - 500 unique recipients per day **Free Gmail accounts**: - 500 emails per day - 500 recipients per message **Good news**: Workflow notifications rarely hit these limits. If you're sending 50 task notifications daily, you're using just 2.5% of your quota. We'll also implement smart batching to combine multiple notifications when possible. ### Will emails appear in my Sent folder? **Yes - every email Tallyfy sends appears in your Gmail Sent folder.** This creates a complete audit trail in your familiar email interface. You can: - Search your Sent folder for any workflow email - See exactly what was sent and when - Forward or reply to continue conversations - Apply your existing email retention policies This also means: - Your email backup systems capture these messages - Legal discovery includes workflow notifications - You maintain full control over your email history ### How do I revoke access? You can disconnect Tallyfy from your Google account in three ways: **Option 1: From Tallyfy** - Go to Settings → Email Integration - Click "Disconnect Google Account" - Confirmation appears immediately **Option 2: From Google Account Settings** - Visit myaccount.google.com/permissions - Find Tallyfy in the list - Click "Remove Access" **Option 3: Admin removal** (for IT admins) - Google Admin Console → Security → API controls - Find Tallyfy in connected apps - Remove for specific users or entire organization Revocation takes effect immediately. Tallyfy can no longer send emails from your account, though emails already sent remain in your Sent folder. ### What data does Tallyfy store? **We store only the OAuth refresh token - not your emails or password.** Specifically: **What we store**: - OAuth refresh token (encrypted) - Your email address (for display) - Token expiration time - Last successful send timestamp **What we never store**: - Your Google password - Email contents from your inbox - Your contacts - Calendar information - Any other Google data The refresh token is encrypted at rest and can only be used to request short-lived access tokens for sending emails. Even if someone somehow accessed our database, they couldn't read your emails or access your account. ### Integration with Google security features The integration respects all your Google security settings: **2-Factor Authentication**: Fully supported - OAuth works regardless of 2FA **Advanced Protection Program**: Compatible with Google's highest security tier **Context-Aware Access**: Follows your organization's access policies **Security Keys**: Work normally during initial authorization **Suspicious Activity Detection**: Google monitors OAuth usage for anomalies If Google detects unusual activity, they might: - Temporarily block sending - Require you to reauthorize - Send you a security alert - Ask you to confirm the activity This is Google protecting your account - exactly what you want. ### Troubleshooting common authorization issues **"This app is blocked" message** - Your admin has blocked third-party apps - Solution: Ask admin to add Tallyfy to allowed apps - Provide them our OAuth client ID **"Requires admin approval" screen** - Your organization requires admin consent - Solution: Forward the consent link to your IT team - One-time approval unlocks for all users **"Invalid scope" error** - Rare technical issue - Solution: Clear browser cache and try again - Contact support if it persists **Authorization succeeds but sending fails** - Usually a temporary Google API issue - Wait 5 minutes and try again - Check if you've hit daily sending limits **"Token expired" messages** - Normal after 6 months of inactivity - Simply reconnect your account - Takes 30 seconds to reauthorize - **[Microsoft Outlook email connection](https://tallyfy.com/products/pro/integrations/email/connect-your-email/outlook/)**: Microsoft Outlook integration will use Graph API with delegated Mail.Send permissions to let users send workflow emails directly from their personal email addresses while maintaining full security compliance and respecting organizational policies. ## How will Microsoft Outlook integration work? **This planned feature will connect your Microsoft 365 or Outlook.com account so Tallyfy can send workflow emails directly from your email address.** We'll use Microsoft Graph API with only the `Mail.Send` permission - just enough to send emails as you, without reading your inbox or accessing your calendar. Here's what makes this powerful: Microsoft Graph is the modern way to integrate with Microsoft 365. Unlike the old SMTP authentication that Microsoft is phasing out, Graph API uses secure OAuth tokens and respects all your organization's security policies. Your IT team keeps full control while you get seamless email integration. ### What's Microsoft's app registration process? **Tallyfy will register as an Azure AD application with Microsoft, requiring publisher verification.** This one-time process establishes trust between Tallyfy and Microsoft's identity platform. The registration includes: - **Publisher verification**: Confirms Tallyfy's identity through our Microsoft Partner account - **App manifest configuration**: Defines exactly what permissions we request - **Consent screen customization**: Shows clear information about what users are authorizing - **Security compliance review**: Documents our data handling practices Microsoft's requirements are straightforward for send-only permissions: - No security assessment needed for `Mail.Send` scope - Standard verification takes 1-2 weeks - Publisher verification requires valid Microsoft Partner ID - Domain ownership must be verified :::note[Avoiding Restricted Scopes] We deliberately avoid requesting `Mail.Read` or `Mail.ReadWrite` permissions. These "restricted" scopes would require expensive annual security assessments. By limiting ourselves to `Mail.Send`, we keep the integration simple and secure. ::: ### How do delegated vs application permissions work? **We'll use delegated permissions, meaning users explicitly authorize Tallyfy to send on their behalf.** This is more secure than application permissions which would let us send as anyone in your organization. **Delegated permissions (what we use)**: - Each user authorizes individually - Users see exactly what they're granting - Permissions tied to specific user accounts - Can be revoked by users anytime - Shows "sent on behalf of" in email headers **Application permissions (what we don't use)**: - Would require admin consent for entire organization - Could send as any user without their knowledge - Higher security risk - More complex approval process - Not necessary for our use case The delegated model means you stay in control. You decide if and when to connect your account, and you can disconnect anytime. ### What about admin consent requirements? **Whether you need admin approval depends on your organization's Azure AD settings.** Microsoft 365 organizations fall into three categories: **Scenario 1: User consent allowed (most common)** - Default setting for many organizations - Users can approve apps requesting basic permissions - Connect your account in 2 minutes - No IT involvement needed **Scenario 2: Admin consent required for new apps** - Organization requires admin review of new applications - Admin gets notification when you try to connect - One-time approval for entire organization - After approval, all users can connect freely **Scenario 3: All third-party apps blocked** - Strictest security setting - No apps allowed without explicit admin approval - Requires security review and exception process - May need business justification We'll detect your organization's settings automatically and guide you through the appropriate process. ### How do IT admins pre-approve Tallyfy? We provide admins with: - Complete setup documentation with screenshots - Our Azure AD application ID - Security compliance certificates - Technical support contact - Rollback procedures if needed ### Will this work with conditional access policies? **Yes - Tallyfy respects all your conditional access policies.** If your organization requires specific conditions for app access, we'll comply: **Supported policies**: - Multi-factor authentication (MFA) - Trusted device requirements - Location-based restrictions - Session lifetime limits - Risk-based authentication When a policy triggers: 1. User attempts to connect account 2. Azure AD evaluates policies 3. Additional authentication requested if needed 4. Once satisfied, connection proceeds 5. Policies re-evaluated periodically This means your security team can: - Require MFA for Tallyfy connections - Limit access to corporate devices - Block connections from certain countries - Force re-authentication every 30 days ### How does this handle email sending limits? **Microsoft 365 has daily sending limits that apply to Graph API sends.** These limits protect against spam and abuse: **Microsoft 365 Business/Enterprise**: - 10,000 recipients per day - 500 recipients per message - 30 messages per minute rate limit **Outlook.com (personal)**: - 300 emails per day - 100 recipients per message - Lower rate limits **Exchange Online Protection** adds: - Reputation-based sending - Automatic throttling if limits approached - Temporary blocks for unusual activity Don't worry - workflow notifications rarely approach these limits. If you send 100 task notifications daily, you're using just 1% of your quota. We'll also implement intelligent batching to stay well within limits. ### What about Exchange on-premises? **The initial release will support cloud-based Microsoft 365 and Outlook.com only.** Exchange on-premises (self-hosted Exchange servers) requires different integration methods: **Why on-premises is different**: - No Azure AD for authentication - Requires hybrid connectivity setup - Graph API access needs special configuration - Additional firewall considerations **Future on-premises support** might include: - Exchange Web Services (EWS) integration - Hybrid modern authentication - ADFS federation support - Partner with your Exchange team for setup If you use on-premises Exchange, let us know - we're tracking demand for this capability. ### Will emails show in my Sent Items? **Yes - every email sent through Graph API appears in your Sent Items folder.** This maintains a complete audit trail: - Full copy in Sent Items immediately - Searchable through Outlook - Subject to retention policies - Included in backups - Available for legal discovery This also enables: - Reply tracking from your sent folder - Forward workflow emails to others - Archive important notifications - Apply categories and flags - Include in email rules Your existing Outlook features work normally with these emails. ### How does token refresh work? **Microsoft access tokens expire after 1 hour, but we handle refresh automatically.** Here's the lifecycle: 1. **Initial authorization**: You sign in and grant permission 2. **Access token issued**: Valid for 1 hour 3. **Refresh token provided**: Valid for 90 days with activity 4. **Automatic refresh**: We get new access tokens as needed 5. **Sliding window**: Each use extends refresh token life You don't need to re-authenticate unless: - You explicitly revoke access - 90 days pass without any email sends - Your organization's policies force re-authentication - Microsoft detects security concerns The process is seamless - you connect once and forget about it. ### Security and compliance features The Microsoft integration includes enterprise security features: **Data residency**: - Emails processed in your Microsoft 365 region - No data leaves your geography - Complies with data sovereignty requirements **Audit logging**: - All API calls logged in Azure AD - Sign-in events tracked - Admin audit reports available - Unusual activity alerts **Compliance standards**: - GDPR compliant data handling - SOC 2 certification aligned - HIPAA compatible (with BAA) - ISO 27001 practices **Zero Trust compatibility**: - No standing permissions - Just-in-time token access - Continuous verification - Least privilege principle ### Integration with Microsoft security tools The connection works with Microsoft's security ecosystem: **Microsoft Defender for Office 365**: - Scans outbound emails - Applies anti-malware policies - Checks for data loss prevention (DLP) - Blocks suspicious content **Microsoft Purview**: - Information protection labels apply - Retention policies enforced - eDiscovery includes sent emails - Compliance boundaries respected **Azure AD Identity Protection**: - Risk-based conditional access - Unusual activity detection - Automated response to threats - User risk evaluation These tools work transparently - your security policies apply to Tallyfy-sent emails just like regular emails. ### Troubleshooting common Microsoft issues **"Need admin approval" message** - Your organization requires admin consent - Click "Request approval" to notify admin - Or share our pre-approval guide with IT **"AADSTS65001: User or admin has not consented"** - App needs to be added to your tenant - Admin must grant consent first - We'll provide setup instructions **"Invalid client" error** - Usually a browser cache issue - Try incognito/private browsing mode - Clear cookies for login.microsoftonline.com **"Token expired" after connection** - Normal if unused for 90+ days - Simply reconnect your account - Takes 1 minute to reauthorize **Emails not appearing in Sent Items** - Check if Purview policies are archiving - Verify retention policies aren't deleting - Confirm mailbox has sufficient storage **"SendAs permission denied"** - Trying to send from shared mailbox - Only personal mailbox sending supported initially - Shared mailbox support planned for future ### Microsoft 365 GCC and GCC High **Government cloud support is planned for a future release.** Microsoft's government clouds require additional compliance: **GCC (Government Community Cloud)**: - Separate app registration required - FedRAMP Moderate compliance needed - Different Graph API endpoints **GCC High / DoD**: - ITAR compliance required - Isolated environment registration - Enhanced security review If you're in government cloud, contact us to join the priority list for this capability. ### Middleware - **[Stream data to a spreadsheet](https://tallyfy.com/products/pro/integrations/middleware/how-can-i-export-form-fields-from-tallyfy-to-spreadsheet/)**: Tallyfy automatically exports form field responses to spreadsheet applications like Google Sheets and Excel Online through middleware platforms such as Zapier Make or Power Automate enabling centralized data collection advanced reporting and smooth business tool integration. ## Export form fields to spreadsheets automatically You can automatically send [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) responses from Tallyfy straight to Google Sheets or Excel Online. No manual copying needed. Here's why this matters: your form data flows directly into spreadsheets for instant reporting and analysis. [Middleware](/products/pro/integrations/middleware/) platforms like Zapier, Make, or Power Automate handle the connection - they're the bridge between Tallyfy and your favorite spreadsheet app. ### Why should I export Tallyfy form data to spreadsheets? Let's be honest - spreadsheets are where most teams actually analyze their data. When you export Tallyfy form responses, you unlock several practical benefits: - **Centralized Data Collection**: All your process responses land in one spreadsheet. Simple. - **Advanced Reporting**: Build charts and dashboards using Excel or Google Sheets' built-in tools - **Historical Record Keeping**: Every form submission gets logged permanently for audits and compliance checks - **System Integration**: Spreadsheets connect to almost everything - use them as your data hub - **Better Data Sharing**: Your team already knows spreadsheets (no training required) ### How to set it up using middleware Pick a [middleware](/products/pro/integrations/middleware/) tool that fits your needs: - **Zapier**: Great for beginners. Lots of pre-built connections make setup take about 10 minutes. - **Microsoft Power Automate**: Perfect if you're already using Microsoft 365 (works smoothly with Excel Online). - **Make.com** (formerly Integromat): More powerful but takes longer to learn - worth it for complex workflows. - **Custom Code**: Your developers can connect directly using Tallyfy [webhooks](/products/pro/integrations/webhooks/) and the [API](/products/pro/integrations/open-api/). :::note[Choosing a Tool] For simple connections, Zapier is fine. For more complex needs or higher volume, consider **Make.com** or **Microsoft Power Automate**. Using the Tallyfy **API** directly offers the most control but requires coding. ::: ### General setup steps The setup process stays pretty consistent across middleware tools. Here's what you'll do: ### Video example using Zapier Want to see this in action? This video walks through the Zapier setup - the same principles work for other tools: - **[Why use middleware?](https://tallyfy.com/products/pro/integrations/middleware/why-should-i-use-an-integration-platform-with-tallyfy/)**: Middleware platforms like Zapier and Make.com provide pre-built connectors and automatic maintenance that eliminate the need to manually handle API updates and error management when connecting Tallyfy to other business applications. ## Why should you use middleware platforms instead of custom API code? Integration platforms typically beat custom API code for most use cases. When you need to connect Tallyfy to other software your business uses, middleware tools like Zapier, Make, or Power Automate save you significant development time - and headaches down the road. ### What does an integration platform do? Picture a universal translator sitting between Tallyfy and your other apps. That's middleware. Here's what you get: - Ready-made connections to hundreds of popular apps - Tools to transform data from Tallyfy's format to another app's format - Automatic error handling when connections fail temporarily - Monitoring dashboards to watch your connections - Visual interfaces - no code required (usually) The big players? Microsoft Power Automate, Zapier, Make.com, and Workato. :::note[Choosing a Tool - Reminder] Zapier works fine for basic stuff. But if you're building something serious, **Make.com** or **Microsoft Power Automate** handle complex logic better. Developers who want complete control should check out Tallyfy's [Open API](/products/pro/integrations/open-api/). ::: ### Key reasons to use middleware #### 1. Less Hassle with Updates APIs change constantly - that's just reality. With middleware, you're protected: - **Less work for you**: When Tallyfy or another app updates its API, the middleware company fixes their connector. Not your problem anymore. - **Stays compatible**: The platform handles different API versions behind the scenes - **Ongoing support**: Your connections keep working as apps evolve #### 2. Faster Setup with Pre-Built Connectors Why reinvent the wheel? Middleware gets you running in minutes: - **Huge libraries**: Access hundreds of ready-to-use connectors for popular apps - **Tested connections**: These connectors are battle-tested by thousands of users - **Configure, don't code**: Click, configure, done. No coding marathons required. #### 3. More Ways to Start Workflows Need flexibility? You've got it: - **Many trigger types**: Time-based, data-driven, or event-triggered - take your pick - **Smart triggers**: Add filters and logic to control exactly when connections fire - **Multi-app triggers**: Watch several apps at once and coordinate complex workflows #### 4. Built-in Tools You Don't Have to Build Here's the boring stuff that middleware handles so you don't have to: - **Error handling**: Connection drops? The platform retries automatically - **Data transformation**: Split names, reformat dates, clean messy data - all built in - **Monitoring**: Real-time logs show exactly what happened (and when things break) - **Security**: Login credentials stored safely, connections managed properly ### Recommended approach Got some custom requirements? No problem. Here's the smart way to handle them: 1. Build your main connection flow **inside** the middleware platform first 2. Add small custom code snippets only where you absolutely need them 3. Let the platform handle all the error handling, monitoring, and maintenance You get the flexibility of custom code without the headache of maintaining everything yourself. Best of both worlds. ### Which platform to choose? Each platform has its sweet spot: - **Microsoft Power Automate**: Already using Microsoft 365? This integrates seamlessly. - **Zapier**: Dead simple to start with. Perfect for your first automation. - **Make.com**: When you need complex data transformations and branching logic - **Workato**: Enterprise-grade with advanced features for larger organizations - **[Integrate to your CRM or ERP](https://tallyfy.com/products/pro/integrations/middleware/integrate-into-crm/)**: Tallyfy connects to CRM and ERP systems to bridge the gap between sales stages and the dozens of micro-tasks that must happen between each transition ensuring complex operational workflows run smoothly while maintaining detailed audit trails and cross-team collaboration that traditional CRM systems cannot provide. ## Connecting Tallyfy to your CRM or ERP system You can connect Tallyfy to your Customer Relationship Management (CRM) system (like Salesforce or SFDC, HubSpot, Microsoft Dynamics 365, etc.) or Enterprise Resource Planning (ERP) system such as Netsuite, SAP, etc. This connection lets you link your sales or operational processes managed in the CRM/ERP with detailed workflows that run in Tallyfy. ### Why connect Tallyfy to your CRM/ERP? - **Save on licenses**: Run detailed operational workflows in Tallyfy without buying expensive CRM/ERP licenses for everyone who needs to be involved. - **Consistent processes**: Ensure standard procedures (like client onboarding or support) are followed - even when you're involving teams outside the CRM/ERP. - **Smooth handoffs**: Make transitions between teams (like Sales to Operations) trackable and consistent. - **Better client experience**: Give clients a consistent journey from first contact through delivery. ### The critical gap between CRM stages (and how Tallyfy fills it) CRMs track your deals through stages - Lead, Qualified, Proposal, Negotiation, Closed Won. But here's what they miss: the dozens of micro-tasks that must happen between each stage transition. These invisible tasks determine whether deals progress or stall. Think about what really happens when a deal moves from "Qualified" to "Proposal" stage. It's not one click - it's a cascade of coordinated activities: technical reviews, pricing approvals, legal checks, resource allocation, competitor analysis, and custom demo preparation. Each involves multiple people, specific deadlines, and conditional logic based on deal characteristics. Tallyfy makes these micro-tasks visible, trackable, and automatic. While your CRM shows the big picture, Tallyfy ensures every critical step between stages gets done right. ### What CRMs cannot do (but Tallyfy works perfectly for) CRMs excel at storing customer data and tracking sales activities. But they fall short when you need to manage complex operational workflows. Here's where businesses hit roadblocks with CRM-only approaches: #### Inflexible task sequences CRMs force you into rigid, linear task flows that can't handle real business complexity. Does your client onboarding need different steps based on deal size, location, or service type? You're stuck with manual workarounds or duplicate processes. Tallyfy's [conditional automations](/products/pro/documenting/templates/automations/conditionals/) automatically show or hide steps based on form answers. Personalized workflows without the headache. #### Missing accountability and notifications Most CRMs require people to log in daily and manually check for pending tasks. No automatic assignment of next steps. No deadline management across complex multi-step processes. It's exhausting. Tallyfy automatically assigns tasks to the right people at the right time, sends deadline reminders, and escalates overdue items - workflows move forward without manual oversight. #### Fragmented cross-team collaboration CRMs work well for sales teams but what happens when processes involve people outside the system? Legal, Finance, external partners - information gets trapped in silos. Missed handoffs. Inconsistent execution. Tallyfy lets you involve anyone - internal [members](/products/pro/documenting/members/) or external [guests](/products/pro/documenting/guests/) - in the same workflow. Everyone sees their specific tasks and deadlines. #### Weak audit trails and compliance CRMs track data changes but don't keep detailed records of who did what task, when, and in what order. For regulated industries or quality processes, this creates massive compliance gaps. Every Tallyfy [process](/products/pro/tracking-and-tasks/processes/) automatically creates a complete audit trail. You see exactly what happened, when, and by whom - perfect for compliance reporting or process improvement. #### Disconnected tool ecosystem CRMs integrate with some tools, sure. But they can't coordinate complex workflows that span multiple systems. You end up with manual data entry between your CRM, project management tools, document systems, and communication platforms. Hours wasted. Tallyfy sits above these tools, connecting them through [middleware](/products/pro/integrations/middleware/) to create smooth end-to-end processes. Each tool does what it does best. ### Real examples of micro-tasks between CRM stages #### Lead → Marketing Qualified Lead (MQL) Your CRM shows a lead. But converting it to MQL requires micro-tasks that CRMs can't track: - Research company size and industry fit (assigned to SDR) - Verify email and phone accuracy (marketing ops task) - Check for existing customer conflicts (account management review) - Score based on engagement metrics (automated calculation) - Enrich data from third-party sources (operations task) Tallyfy launches this 5-task workflow automatically when a new lead enters your CRM. Each task has its owner, deadline, and completion criteria. The lead only advances to MQL when all micro-tasks complete successfully. #### MQL → Sales Qualified Lead (SQL) Moving from marketing-qualified to sales-qualified isn't just changing a dropdown. It triggers: - Schedule discovery call (SDR task with calendar integration) - Prepare industry-specific talking points (sales enablement creates) - Identify decision makers via LinkedIn (research task) - Check credit and payment history (finance verification) - Create personalized demo environment (solutions engineering prep) Without Tallyfy, these tasks happen inconsistently - or not at all. Sales reps waste time in meetings they're unprepared for. #### SQL → Opportunity Creating an opportunity triggers a complex orchestration: - Define solution requirements (solutions architect, 2-day deadline) - Estimate implementation timeline (delivery team input required) - Calculate pricing with discounts (needs manager approval if >20%) - Assess competitive landscape (marketing provides battlecards) - Identify risks and dependencies (cross-functional review) Tallyfy's conditional logic adjusts this workflow based on deal size. Enterprise deals add security reviews and legal pre-approval steps automatically. #### Opportunity → Closed Won The most critical transition needs flawless execution: - Generate MSA and SOW (legal, varies by jurisdiction) - Obtain final pricing approval (CFO for deals >$100k) - Coordinate signature process (DocuSign integration) - Create implementation project (auto-generates from template) - Schedule kickoff call (CSM with available resources) - Provision accounts and access (IT and security tasks) - Send welcome package (marketing automation trigger) Each micro-task must complete in sequence, with the right person, at the right time. CRMs can't orchestrate this complexity - they just show "Closed Won" while chaos happens behind the scenes. ### Common connection examples #### Lead management - New lead appears in your CRM? Automatically kick off a lead qualification process in Tallyfy. - Assign tasks in Tallyfy for researching or contacting the lead. - Send updated lead information back to the CRM record. #### Sales stage changes - Deal moves to a new stage in your CRM (like "Proposal Sent")? The relevant Tallyfy process starts automatically (like "Contract Review"). - Include people who don't use the CRM (like Legal or Finance) in necessary steps. #### Client onboarding - Deal marked "Won" in the CRM? The detailed client onboarding process launches in Tallyfy instantly. - Hand off tasks to the implementation or customer success team with zero friction. - Even invite the client as a guest to participate in specific onboarding tasks. #### Standardizing support - Use Tallyfy to manage complex or multi-step customer support procedures. - Ensure support agents follow consistent steps for specific types of issues - every single time. - Train new support staff 3x faster using standard Tallyfy templates. ### Why micro-task visibility determines sales success Sales leaders often wonder why similar opportunities have wildly different outcomes. The answer lies in the execution of micro-tasks between CRM stages. Two deals might both show "Proposal Stage" in your CRM, but their underlying realities differ completely: **Deal A (without Tallyfy micro-task management):** - Proposal sent without technical review (errors discovered later) - Pricing approved verbally but not documented (confusion during negotiation) - Implementation team not consulted (unrealistic timeline promised) - Legal review skipped to "save time" (contract revisions delay close by weeks) **Deal B (with Tallyfy orchestrating micro-tasks):** - Technical review completed, dependencies identified - Pricing approved in writing with all stakeholders aligned - Implementation team confirmed resource availability - Legal pre-approved standard terms, exceptions documented Both deals look identical in the CRM. But Deal B closes 3x faster with fewer surprises because Tallyfy ensured every micro-task between stages was completed properly. This isn't about adding bureaucracy - it's about making the right things happen automatically. ### How to connect using middleware or links Most connections are built using [middleware](/products/pro/integrations/middleware/) platforms (Zapier, Make, Power Automate, etc.). Direct links work too. :::note[Choosing Middleware] As mentioned elsewhere, Zapier is fine for simple links. For more robust connections, consider Make.com or Power Automate. Developers can use the Tallyfy API for full control. ::: ![](https://screenshots.tallyfy.com/tallyfy-salesforce-widget.png) ## Integration flow visualization This diagram shows how data flows between your CRM/ERP and Tallyfy through middleware connections. [Diagram removed for brevity] ### What to notice - **Record ID preservation**: The CRM record ID passes through the entire flow - first from CRM to Tallyfy (step 3), then back from Tallyfy to CRM (step 9) - ensuring updates hit the correct record - **Middleware as the bridge**: Notice how middleware (steps 7-9) handles the complex data transformation and routing between Tallyfy's webhook format and your CRM's API requirements - **Two distinct flows**: The diagram clearly separates launching Tallyfy processes from your CRM (steps 1-4) versus updating CRM records from Tallyfy (steps 6-10) - you can implement either or both based on your needs Here's how information flows between systems: #### 1. Start Tallyfy processes FROM your CRM/ERP Want to launch Tallyfy workflows right from your CRM? Use a [magic link](/products/pro/launching/triggers/magic-links/) to create a button or link inside your CRM/ERP. 1. Create a Tallyfy magic link for the template you want to launch. 2. Set up the link to pull information (contact name, company, deal ID) from the CRM/ERP record. 3. Add this link as a button or clickable link within your CRM/ERP interface - typically on the Opportunity page. 4. User clicks the link? Tallyfy process starts instantly with all the CRM/ERP information already filled in. Watch it in action: #### 2. Send Tallyfy form data TO your CRM/ERP You can also update your CRM/ERP records with information collected in Tallyfy forms. Here's how: 1. Set up a Tallyfy [webhook](/products/pro/integrations/webhooks/) to trigger when a specific Tallyfy form/task gets completed. 2. Use a middleware tool to catch the webhook data. 3. Configure the middleware to find the correct record in your CRM/ERP (using an ID passed from the CRM initially - see below) and update specific fields with the Tallyfy form answers. **Important**: To update the *correct* record in your CRM/ERP (the right Contact or Deal), you'll need that record's unique ID. Pass this ID *from* the CRM/ERP *into* Tallyfy when the process starts (yes, using the magic link method above). Then you can use it later to find the right record to update. - **[Celigo](https://tallyfy.com/products/pro/integrations/middleware/celigo/)**: Tallyfy's native Celigo connector is under development to enable bidirectional workflow automation between Tallyfy and enterprise systems like NetSuite and Salesforce through process triggers task management and data synchronization capabilities. ## Planned Celigo integration for Tallyfy workflows :::note[Coming Soon - Developer Preview Available] Tallyfy's native Celigo connector is under active development. While not yet available in Celigo's marketplace, developers can build custom integrations today using Celigo's developer program and Tallyfy's REST API. Contact [Tallyfy support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/) to join our beta program or get early access credentials. ::: Celigo's integrator.io platform specializes in connecting enterprise systems - particularly NetSuite, Salesforce, and other business applications. Celigo added initial Tallyfy connector support in their 2023.5.1 release, providing basic API operations. The upcoming native connector will expand these capabilities, enabling organizations to automate complex workflows that span multiple systems with full process management integration. ### How the Tallyfy-Celigo connector will work The planned integration will use Celigo's universal HTTP connector architecture and API management capabilities to create bidirectional data flows between Tallyfy and your other business systems. **Key integration patterns we're designing:** 1. **Process triggers from business events** - Sales orders in NetSuite automatically launch approval workflows in Tallyfy 2. **Task completion webhooks** - Completed Tallyfy tasks update records in connected systems through Celigo flows 3. **Data synchronization** - Keep process data synchronized across Tallyfy, your ERP, CRM, and other platforms 4. **Automated assignments** - Use Celigo's data transformations to dynamically assign Tallyfy tasks based on business rules ### Planned connector capabilities Our Celigo connector will support these core functions: **Process automation:** - Launch Tallyfy processes from any Celigo-connected application - Trigger processes based on business events (new customer, order threshold, contract renewal) - Pass data from source systems into Tallyfy kick-off forms - Handle complex conditional logic using Celigo's flow builder **Task management:** - Complete tasks programmatically when conditions are met in other systems - Reassign tasks based on workload or availability data - Update task form fields with data from integrated applications - Create comments and track issues across platforms **Data operations:** - Export process metrics to data warehouses through Celigo - Synchronize master data between Tallyfy and business systems - Transform data formats using Celigo's mapping capabilities - Maintain audit trails across all connected applications ### Architecture overview The connector will utilize Celigo's SmartConnector framework: ``` Your Systems → Celigo Platform → Tallyfy API ↓ ↓ ↓ NetSuite Data Transform Process Launch Salesforce Field Mapping Task Updates Shopify Error Handling Data Export Custom Apps Retry Logic Webhooks ``` **Authentication approach:** - OAuth 2.0 bearer tokens for secure API access - Encrypted credential storage in Celigo's platform - Support for multiple Tallyfy organizations - Rate limit management and automatic retries ### Implementation scenarios **Order-to-fulfillment workflow:** When a high-value order enters NetSuite, Celigo triggers a Tallyfy approval process. The process routes through finance review, credit check, and management approval. Each approval in Tallyfy updates the order status in NetSuite through Celigo's bidirectional sync. **Employee onboarding automation:** New employee records in your HRIS system trigger complete onboarding processes in Tallyfy. Celigo orchestrates data flow between HR systems, IT provisioning tools, and Tallyfy's task management - ensuring nothing falls through the cracks. **Customer escalation handling:** Support tickets reaching priority thresholds in your CRM automatically launch Tallyfy escalation workflows. Celigo maintains synchronization between ticket status, Tallyfy task progress, and customer communication platforms. ### Practical implementation examples **Creating a task via Celigo:** ```javascript // Celigo flow configuration for task creation { "operation": "create_task", "connection": "tallyfy_oauth", "mapping": { "name": "{{source.task_title}}", "description": "{{source.task_description}}", "assignee": "{{source.assigned_user}}", "due_date": "{{source.deadline}}" } } ``` **Launching a process from external trigger:** ```javascript // Trigger Tallyfy process when CRM opportunity closes { "operation": "create_process", "blueprint_id": "customer_onboarding_v2", "kickoff_data": { "customer_name": "{{crm.account_name}}", "contract_value": "{{crm.deal_amount}}", "start_date": "{{crm.close_date}}" } } ``` ### Developer program and marketplace listing Celigo enables third-party developers to create and publish connectors through their developer program. Once enrolled, you can: - Access integration app development tools - Build custom Tallyfy connectors using REST API - Package and publish solutions to Celigo's marketplace - Support OAuth 2.0 and token-based authentication - Handle webhook events for real-time triggers To get started, contact Celigo to enroll in their Third-Party Developer Program, which grants access to create and publish integration templates. ### Authentication options for developers **Personal Access Token**: - Quick development approach using user API tokens - Navigate to Settings > Integrations > REST API in Tallyfy - Copy your access token for immediate use - Token acts on behalf of the user account **OAuth 2.0 (Recommended for production)**: - Best for public connectors with customer authorization - Contact Tallyfy support for Client ID and Client Secret - Supports granular permission scopes - Handles token refresh automatically - Encrypted credential storage in Celigo ### Building custom integrations today While waiting for the native connector, you can integrate Tallyfy with Celigo using these approaches: **Universal HTTP connector:** 1. Create a new HTTP connection in Celigo 2. Configure authentication using Tallyfy API tokens 3. Map Tallyfy's REST endpoints for processes and tasks 4. Build flows using Celigo's visual interface **Webhook intermediary pattern:** 1. Set up Tallyfy webhooks to send events to a middleware endpoint 2. Configure Celigo to poll or receive these events 3. Process events through Celigo flows to update connected systems 4. Use Celigo's API management to create reusable integration endpoints **Real-time triggers with webhooks:** - Configure webhook listeners in Celigo for Tallyfy events - React to task completions, process launches, status changes - Celigo generates unique URLs to receive webhook payloads - Combine with scheduled exports for reliable event processing - Enable bidirectional sync between Tallyfy and other systems **Core Tallyfy API endpoints:** - `POST /api/v1/processes` - Launch new processes from blueprints - `POST /api/v1/tasks` - Create standalone tasks - `GET /api/v1/tasks` - Retrieve task details and status - `PUT /api/v1/tasks/{id}` - Update task status or mark complete - `POST /api/v1/webhooks` - Configure real-time event notifications - `GET /api/v1/blueprints` - List available process templates - `POST /api/v1/runs` - Create process instances (alternative endpoint) **API terminology mapping:** - "Blueprints" in UI = "Checklists" in API - "Processes" in UI = "Runs" in API - "Templates" in UI = "Blueprints" in API ### Technical requirements To prepare for the Celigo integration: **Tallyfy configuration:** - API access enabled in your Tallyfy organization - REST API token or OAuth credentials obtained - Webhook endpoints configured for relevant events - Process templates designed with integration fields - User permissions set for system accounts - Review API documentation at go.tallyfy.com/api **Celigo platform setup:** - integrator.io account with appropriate licensing - Universal connector permissions enabled - API rate limits configured for Tallyfy endpoints - Error handling and alerting rules defined ### Why Celigo for workflow automation Celigo brings unique strengths to process automation: - **Pre-built connectors** - 200+ applications already integrated - **Enterprise scale** - Handles millions of transactions daily - **Error recovery** - Automatic detection and resolution of data issues - **Visual flow builder** - No-code integration design for business users Combined with Tallyfy's process management, you get end-to-end automation across your entire technology stack. ### Certification and marketplace publication For developers creating custom Tallyfy connectors: **Publishing process:** 1. Build and test integration flows in Celigo 2. Package as an Integration App with clear naming 3. Include Tallyfy logo and detailed description 4. Enable published status in Integration Apps settings 5. Schedule certification demo with Celigo's product team 6. Receive approval for marketplace listing **Testing recommendations:** - Verify all core actions (create task, complete task, launch process) - Test both OAuth and token authentication methods - Implement error handling and retry logic - Use separate sandbox account for development - Document all supported API operations ### Getting early access The official Tallyfy-Celigo connector is under development. To participate: 1. Contact [Tallyfy support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/) to join the beta program 2. Request OAuth credentials for connector development 3. Share your specific use cases and integration requirements 4. Provide feedback on the planned capabilities outlined above We're particularly interested in hearing about: - Your current Celigo integrations that could benefit from workflow automation - Specific data fields you need to synchronize - Volume and frequency of process launches you anticipate - Complex routing rules or conditional logic requirements - **[Make](https://tallyfy.com/products/pro/integrations/middleware/make/)**: Make visually connects Tallyfy with hundreds of apps through drag-and-drop scenario workflows that automatically trigger processes and sync data across your technology stack. ## Visual workflow automation with Make Make (formerly Integromat) is a powerful visual [integration](/products/pro/integrations/) platform that connects Tallyfy with hundreds of business applications. For background on how automation transforms business operations, explore our [workflow automation guide](https://tallyfy.com/workflow-automation/). Using scenario-based workflows, you can automate complex multi-step [processes](/products/pro/tracking-and-tasks/processes/) across your entire technology stack. ### Key capabilities - **Trigger [processes](/products/pro/tracking-and-tasks/processes/) automatically** - [Launch](/products/pro/launching/) workflows based on events in connected applications - **Complete [tasks](/products/pro/tracking-and-tasks/tasks/) programmatically** - Mark tasks as complete when external conditions are met - **Capture form data** - Send [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) submissions to external systems - **Visual scenario builder** - Create complex multi-step automations with an intuitive drag-and-drop interface - **Advanced data transformation** - Use built-in functions to transform and route data between applications ### Why choose Make for Tallyfy integrations? Make offers several advantages for connecting Tallyfy with other systems: - **Flexible pricing** - Various pricing tiers available based on usage and scenario complexity - **Visual debugging** - See exactly how data flows through your scenarios - **Error handling** - Built-in error handling and retry mechanisms - **Data transformation** - Powerful functions for manipulating data between steps - **Scheduling flexibility** - Run scenarios on demand, on schedule, or triggered by events ### Common integration scenarios - [Launch](/products/pro/launching/) onboarding processes when new records appear in HR systems - Create [tasks](/products/pro/tracking-and-tasks/tasks/) when support tickets arrive in helpdesk platforms - Send completed [form data](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) to CRM or ERP systems - Notify teams in Slack or Microsoft Teams when critical [processes](/products/pro/tracking-and-tasks/processes/) complete - Synchronize data between Tallyfy and your business applications ### Getting started with Make 1. Create a Make account at make.com 2. Connect Tallyfy using the [Open API](/products/pro/integrations/open-api/) 3. Build scenarios using HTTP modules or custom apps 4. Test your integration with sample data 5. Activate and monitor your automated workflows For maximum flexibility, use Tallyfy's [Open API](/products/pro/integrations/open-api/) with Make's HTTP module to build custom integrations tailored to your specific requirements. - **[n8n](https://tallyfy.com/products/pro/integrations/middleware/n8n/)**: n8n connects Tallyfy with over 400 business applications through visual workflows using a dedicated connector with 60+ operations while offering self-hosting options and AI-native automation capabilities for launching processes managing tasks and orchestrating cross-system data synchronization. ## What is n8n and how does it work with Tallyfy? n8n connects Tallyfy with 400+ business applications through visual workflows. For a broader perspective on automation strategies, see our guide on [how to automate business processes](https://tallyfy.com/automate-business-processes/). It's an AI-native automation platform that's rapidly becoming the developer-friendly alternative to Zapier and Make. You can self-host for complete control or use their cloud service - your choice. ![n8n main interface showing sidebar navigation with projects, templates, variables, and Editor/Executions/Evaluations tabs](https://screenshots.tallyfy.com/tallyfy/pro/n8n-main-interface.png) n8n has grown rapidly as a developer-friendly automation platform with a thriving community of users and community-built integrations. What makes this particularly exciting for Tallyfy users is n8n's focus on AI-first automation - many workflows incorporate AI or LLM integrations. Tallyfy has a dedicated n8n connector that provides seamless integration through 60+ operations across 10 resources. The connector supports everything from launching processes to managing tasks, users, and form fields. You can also use n8n's flexible HTTP Request and Webhook nodes for custom integrations with Tallyfy's [Open API](/products/pro/integrations/open-api/) and [webhooks](/products/pro/integrations/webhooks/). :::tip[Why choose n8n?] n8n's fair-code license and self-hosting options eliminate vendor lock-in while keeping costs predictable. The platform's AI-native approach means you can combine traditional automation with LLM capabilities in a single workflow. Plus, when visual building isn't enough, you can write JavaScript or Python code directly in the workflow. ::: ### Key advantages of n8n for Tallyfy integration: | Feature | Benefit for Tallyfy Users | |---------|---------------------------| | **Dedicated Tallyfy connector** | 60+ operations across blueprints, processes, tasks, users, and more - no custom HTTP requests needed | | **AI-native platform** | Combine Tallyfy automation with AI analysis, content generation, and intelligent routing | | **Self-hosting option** | Deploy on your infrastructure for maximum security, compliance, and cost control | | **Visual workflow builder** | Design complex multi-system integrations with drag-and-drop simplicity | | **Code when needed** | Add JavaScript or Python for advanced logic while keeping most workflow visual | | **400+ integrations** | Connect Tallyfy to CRM, ERP, communication tools, and specialized business systems | | **Enterprise-ready** | Advanced permissions, SSO, air-gapped deployments, and enterprise support | | **Fair pricing model** | Execution-based pricing scales with your business - no surprise costs | | **Unlimited active workflows** | No artificial limits on active workflows (unlike some competitors) | | **Active community** | 2,200+ community nodes and growing ecosystem of specialized integrations | **Understanding n8n's execution-based pricing:** One workflow execution counts as one operation regardless of how many nodes it contains. A 100-node workflow that processes complex logic costs the same as a simple 5-node workflow. This makes n8n particularly cost-effective for sophisticated Tallyfy integrations with multiple data transformations, API calls, and conditional logic. ### Common Tallyfy + n8n integration scenarios: 1. **Intelligent process launching** - Launch Tallyfy processes when specific conditions are met across multiple systems - Use AI to analyze incoming requests and automatically start the right workflow - Trigger processes based on threshold breaches, time schedules, or external events 2. **AI-enhanced data processing** - Analyze form responses with LLMs to extract insights and next actions - Automatically categorize and prioritize processes based on content analysis - Generate executive summaries of completed workflows using AI **Choosing an LLM provider for AI workflows:** n8n supports multiple LLM providers through dedicated nodes. For maximum flexibility, consider using **Open Router** - it lets you switch between different AI models (Claude, GPT-4, Llama, etc.) without rebuilding your workflows. While there's a small premium for this flexibility, the ability to instantly swap models when one underperforms or pricing changes makes it worthwhile for production AI agents. For AI agents that need persistent memory or knowledge bases, **Supabase vector stores** integrate smoothly with n8n and provide better performance than n8n's native data tables for production workloads. 3. **Cross-system orchestration** - Synchronize data between Tallyfy and multiple business systems in real-time - Create complex approval chains that span Tallyfy and external approval systems - Build notification networks that keep stakeholders informed across platforms 4. **Advanced automation patterns** - Use conditional logic to route processes through different paths based on data - Implement automatic escalation when processes stall or deadlines approach - Create feedback loops that improve process efficiency over time 5. **Document and reporting automation** - Generate contracts, reports, and documents based on completed process data - Automatically archive completed processes to document management systems - Create audit trails and compliance reports across multiple systems ### Getting started with n8n and Tallyfy: ### Technical implementation approaches: **Option 1: Dedicated Tallyfy Connector** The easiest approach uses our community-built n8n node with 60+ pre-configured operations: - **Authentication**: Simple credential setup with API token and organization ID - **Operations**: Launch processes, manage tasks, update form fields, handle users and guests - **Built-in features**: Pagination, error handling, and response formatting - **Resource coverage**: Blueprints, processes, tasks, form fields, comments, users, guests, groups, search, and ID finder **Option 2: HTTP Request Node** For custom integrations or advanced use cases: - **Authentication**: Bearer token with your Tallyfy API key - **Base URL**: `https://go.tallyfy.com/api/` - **Content Type**: `application/json` for most requests - **Methods**: Full REST support (GET, POST, PUT, DELETE) **Real-time updates via Webhooks** Set up the Webhook node to receive instant notifications from Tallyfy when tasks complete, processes update, or forms are submitted. Configure your webhook URL in Tallyfy settings and n8n handles the rest automatically. :::note[Handling files in n8n] When working with file uploads from Tallyfy forms, n8n processes binary data and sends files to cloud storage services like Google Drive, Dropbox, or S3. You can use n8n's built-in nodes to work with images, PDFs, and other file types as part of your workflow. File handling in n8n is surprisingly smooth - none of the "encode this, decode that" nonsense you might expect. ::: ### Deployment and enterprise options: **Cloud vs. Self-Hosted Decision Matrix:** | Use Case | Recommended Option | Key Benefits | |----------|-------------------|-------------| | Quick testing and small teams | n8n Cloud | Zero setup, automatic updates, built-in scaling | | Enterprise compliance | Self-hosted | Complete data control, air-gapped deployment, custom security | | High-volume processing | Kubernetes | Horizontal scaling, fault tolerance, resource optimization | | Cost optimization | Docker self-hosted | Predictable costs, no per-execution charges | **Self-Hosting Options:** - **Docker**: Single-command deployment with persistent data - **Kubernetes**: Enterprise-grade scaling with high availability - **npm/Node.js**: Direct installation for maximum control - **Air-gapped**: Complete isolation for sensitive environments **Enterprise Features:** - Advanced user permissions and role-based access control - Single Sign-On (SSO) integration with major identity providers - Audit logging and compliance reporting - Custom branding and white-label deployment - Priority support with SLA guarantees For organizations with strict compliance requirements, n8n's self-hosted option ensures your Tallyfy integration data never leaves your infrastructure while maintaining full automation capabilities. **HIPAA and healthcare compliance:** If your Tallyfy workflows handle protected health information (PHI), you have two paths with n8n: - **Enterprise tier**: n8n offers HIPAA-compliant cloud hosting through their enterprise package - **Self-hosted**: Deploy n8n on your own HIPAA-compliant AWS or Azure infrastructure with your own security controls n8n Cloud's standard tiers cannot provide a Business Associate Agreement (BAA), so healthcare organizations typically choose self-hosting for complete compliance control. Explore the articles below for detailed setup instructions and specific integration examples. - **[Workato](https://tallyfy.com/products/pro/integrations/middleware/workato/)**: Tallyfy is developing a native Workato connector that will enable enterprise-scale bidirectional workflow automation between Tallyfy and business systems like Salesforce SAP and Workday through OAuth 2.0 authentication and recipe-based triggers while developers can currently build custom integrations using Workato's HTTP connector or Connector SDK with Tallyfy's REST API. ## Planned Workato integration for Tallyfy workflows :::note[Coming Soon - Developer Preview Available] Tallyfy's native Workato connector is under active development. While not yet available in Workato's marketplace, developers can build custom integrations today using Workato's Connector SDK and Tallyfy's REST API. Contact [Tallyfy support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/) to join our beta program or get early access guidance. ::: Workato's enterprise automation platform specializes in connecting business systems at scale - handling complex workflows across IT, HR, Finance, and Sales operations. While Workato doesn't currently offer a pre-built Tallyfy connector, the upcoming native connector will expand capabilities significantly, enabling organizations to automate sophisticated multi-system workflows with enterprise-grade reliability and monitoring. ### How the Tallyfy-Workato connector will work The planned integration will use Workato's recipe-based automation engine and API management capabilities to create bidirectional data flows between Tallyfy and your entire technology stack. **Key integration patterns we're designing:** 1. **Process triggers from business events** - CRM opportunities automatically launch sales workflows in Tallyfy 2. **Task orchestration across systems** - Completed Tallyfy tasks trigger actions in ERP, HRIS, and financial systems 3. **Enterprise data synchronization** - Keep process data synchronized across Tallyfy and data warehouses 4. **Intelligent task routing** - Use Workato's data transformations to dynamically assign Tallyfy tasks based on complex business rules ### Planned connector capabilities Our Workato connector will support these core functions: **Process automation:** - Launch Tallyfy processes from any Workato-connected application - Trigger processes based on complex conditional logic using Workato's recipe builder - Pass data from source systems into Tallyfy kick-off forms with field mapping - Handle enterprise-scale volumes with automatic retry and error recovery **Task management:** - Complete tasks programmatically when conditions are met across multiple systems - Reassign tasks based on workload balancing or skill-based routing - Update task form fields with transformed data from integrated applications - Create cross-system comments and audit trails **Data operations:** - Export process metrics to BI platforms through Workato - Synchronize master data between Tallyfy and MDM systems - Transform data formats using Workato's advanced mapping capabilities - Maintain compliance audit trails across all connected applications ### Architecture overview The connector will utilize Workato's enterprise connector framework: ``` Your Systems → Workato Platform → Tallyfy API ↓ ↓ ↓ Salesforce Recipe Engine Process Launch SAP Data Transform Task Updates Workday Error Handling Data Export ServiceNow Monitoring Webhooks ``` **Authentication approach:** - OAuth 2.0 bearer tokens for secure API access - Encrypted credential storage in Workato's vault - Support for multiple Tallyfy organizations and environments - Automatic token refresh and session management ### Implementation scenarios **Deal-to-fulfillment workflow:** When a deal closes in Salesforce, Workato triggers a Tallyfy customer onboarding process. The process pulls customer data from CRM, routes through implementation tasks, provisions accounts in multiple systems, and updates project status in real-time across all platforms. **Employee lifecycle automation:** New hires in Workday trigger complete onboarding processes in Tallyfy. Workato orchestrates data flow between HRIS, IT service management, facilities systems, and Tallyfy's task management - ensuring complete automation from offer letter to first day. **Incident escalation handling:** Service desk tickets reaching SLA thresholds in ServiceNow automatically launch Tallyfy escalation workflows. Workato maintains bidirectional sync between ticket status, Tallyfy task progress, and stakeholder communication platforms. ### Practical implementation examples **Creating a task via Workato recipe:** ```javascript // Workato recipe configuration for task creation { "app": "tallyfy", "action": "create_task", "input": { "name": "{{datapill.task_title}}", "description": "{{datapill.task_description}}", "assignee": "{{datapill.assigned_user}}", "due_date": "{{datapill.deadline}}", "priority": "{{datapill.priority_level}}" } } ``` **Launching a process from external trigger:** ```javascript // Trigger Tallyfy process when opportunity reaches 'Closed Won' { "app": "tallyfy", "action": "launch_process", "input": { "blueprint_id": "customer_onboarding_v2", "kickoff_data": { "customer_name": "{{salesforce.account_name}}", "contract_value": "{{salesforce.opportunity_amount}}", "start_date": "{{salesforce.close_date}}", "account_manager": "{{salesforce.owner_email}}" } } } ``` ### Developer program and marketplace listing Workato enables developers to create and publish connectors through their Connector SDK program. Once enrolled, you can: - Access the cloud-based Connector SDK development environment - Build custom Tallyfy connectors using Ruby DSL - Test connectors with real API calls in sandbox environments - Package and publish to Workato's community library - Support both OAuth 2.0 and API token authentication - Handle webhook events for real-time recipe triggers To get started, sign up for a Workato account and request Connector SDK access through your workspace admin. ### Authentication options for developers **Personal Access Token (Quick Start)**: - Fastest development approach using user API tokens - Navigate to Settings > Integrations > REST API in Tallyfy - Copy your access token for immediate use - Token acts with full permissions of the user account - Remember to include `X-Tallyfy-Client: APIClient` header **OAuth 2.0 (Recommended for production)**: - Best for public connectors requiring user authorization - Contact Tallyfy support for OAuth Client ID and Secret - Supports granular permission scopes - Handles token refresh automatically through Workato - Encrypted credential storage in Workato's connection vault ### Building custom integrations today While waiting for the native connector, you can integrate Tallyfy with Workato using these proven approaches: **HTTP connector method:** 1. Create a new recipe with HTTP connector action 2. Configure authentication using Bearer token header 3. Map Tallyfy's REST endpoints for processes and tasks 4. Build recipes using Workato's visual interface 5. Add error handling and retry logic **Custom connector development:** 1. Access Workato's Connector SDK in your workspace 2. Create new connector project for Tallyfy 3. Define connection configuration with API authentication 4. Implement actions for common operations (launch, complete, update) 5. Test thoroughly before publishing to community library **Webhook recipe pattern:** - Configure webhook triggers in Workato recipes - Set up Tallyfy webhooks to send events to Workato endpoints - Process events through recipe logic to update connected systems - Use Workato's data pills for dynamic field mapping - Enable real-time bidirectional sync between platforms **Core Tallyfy API endpoints for Workato:** - `POST /api/v1/processes` - Launch new processes from blueprints - `POST /api/v1/tasks` - Create standalone tasks - `GET /api/v1/tasks` - Retrieve task details and status - `PUT /api/v1/tasks/{id}` - Update task status or mark complete - `POST /api/v1/webhooks` - Configure real-time event notifications - `GET /api/v1/blueprints` - List available process templates - `POST /api/v1/runs` - Create process instances with kickoff data **API terminology mapping:** - "Templates" in UI = "Blueprints" in API - "Processes" in UI = "Runs" in API - "Form fields" in UI = "Captures" in API - "Steps" in templates = "Tasks" in processes ### Technical requirements To prepare for the Workato integration: **Tallyfy configuration:** - API access enabled in your Tallyfy organization - REST API token or OAuth credentials obtained - Webhook endpoints configured for relevant events - Process templates designed with integration fields - User permissions set for system accounts - Review API documentation at go.tallyfy.com/api **Workato platform setup:** - Workato account with appropriate recipe limits - Connector SDK access for custom development - HTTP connector permissions enabled - Recipe monitoring and error alerts configured - Connection management for secure credential storage ### Why Workato for workflow automation Workato brings unique strengths to process automation: - **Enterprise scale** - Handles millions of transactions with guaranteed delivery - **Recipe marketplace** - Extensive library of pre-built automation templates - **Advanced error handling** - Automatic retry with exponential backoff - **Visual recipe builder** - No-code automation design for business users - **Multi-environment support** - Development, staging, production recipe deployment Combined with Tallyfy's process management, you get complete automation across your entire enterprise technology ecosystem. ### Publishing process for community connectors For developers creating custom Tallyfy connectors: **Development workflow:** 1. Build and test connector in Workato SDK environment 2. Implement core actions (launch process, complete task, update data) 3. Add thorough error handling and logging 4. Document all actions with clear descriptions and examples 5. Test with real Tallyfy API in sandbox environment **Publishing requirements:** 1. Remove all hardcoded credentials from connector code 2. Provide clear connector title and description 3. Upload Tallyfy logo for connector identification 4. Select appropriate category tags (Workflow, Project Management) 5. Accept Workato developer agreement 6. Submit for review (typically approved within 1 business day) **Community connector best practices:** - Include helpful hints in action descriptions - Provide example recipes demonstrating common use cases - Link to Tallyfy API documentation for reference - Offer both token and OAuth authentication options - Keep connector open source for community trust - Set up support channel for user questions ### Getting early access The official Tallyfy-Workato connector is under development. To participate: 1. Contact [Tallyfy support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/) to join the beta program 2. Request guidance on building custom connectors 3. Share your specific use cases and integration requirements 4. Provide feedback on the planned capabilities outlined above We're particularly interested in hearing about: - Your current Workato recipes that could benefit from Tallyfy integration - Specific data transformations you need between systems - Volume and complexity of workflows you plan to automate - Enterprise requirements for error handling and monitoring - **[Zapier](https://tallyfy.com/products/pro/integrations/middleware/zapier/)**: Tallyfy connects to Zapier for automating workflows across thousands of business apps through triggers and actions that launch processes and sync data without coding requirements. ## What can you do with Tallyfy's Zapier integration? Zapier is a cloud-based [integration](/products/pro/integrations/) platform that connects Tallyfy with thousands of popular business applications without coding expertise. If you're new to Zapier, check out our [Zapier explainer](https://tallyfy.com/what-is-zapier/) for a comprehensive overview. By creating automated workflows (called "Zaps"), you can optimize [processes](/products/pro/tracking-and-tasks/processes/) across your technology stack. :::note[Considering Integration Alternatives] Zapier works well for simple connections. For more complex integrations, consider [middleware](/products/pro/integrations/middleware/) solutions like **n8n**, **Make**, or **Microsoft Power Automate** which offer additional capabilities. For maximum control and flexibility, especially if you have development resources, think about using Tallyfy's [Open API](/products/pro/integrations/open-api/) to build custom integrations, potentially using AI to generate code for serverless functions. ::: ### Key capabilities: - **Trigger [processes](/products/pro/tracking-and-tasks/processes/) automatically** - [Launch](/products/pro/launching/) workflows based on events in other systems - **Complete [tasks](/products/pro/tracking-and-tasks/tasks/) programmatically** - Mark tasks as complete when external criteria are met - **Capture form data** - Send [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) submissions to external applications - **Synchronize information** - Keep data consistent between Tallyfy and other platforms - **Schedule recurring [processes](/products/pro/tracking-and-tasks/processes/)** - Set up time-based triggers for regular workflows ### Common integration scenarios: - [Launch](/products/pro/launching/) onboarding processes when new employees are added to HR systems - Create [tasks](/products/pro/tracking-and-tasks/tasks/) when new support tickets arrive in your helpdesk - Send completed [form data](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) to CRM or ERP systems - Notify team members in Slack when critical [processes](/products/pro/tracking-and-tasks/processes/) start or complete - Generate documents when specific tasks are completed ### Implementation approach: 1. Connect your Tallyfy account to Zapier 2. Build Zaps using Tallyfy triggers or actions 3. Test your integration with sample data 4. Turn on and monitor your automated workflows :::note[Handling File Uploads via Zapier] Currently, directly passing file content *from* Tallyfy file upload fields *to* Zapier can have limitations. A common workaround involves using text fields in Tallyfy to store a **link** to the file (hosted in a system like Google Drive, Dropbox, SharePoint, etc.) and passing this link through Zapier instead of the file itself. ::: Explore the articles below for detailed setup instructions and specific integration examples. - **[Power Automate](https://tallyfy.com/products/pro/integrations/middleware/power-automate/)**: Power Automate connects Tallyfy with Microsoft applications and other business systems to automate data flows and system-to-system integrations without coding while Tallyfy handles the human-centric workflow management and process tracking. Microsoft Power Automate (formerly Flow) connects your Tallyfy [processes](/products/pro/tracking-and-tasks/processes/) with the Microsoft ecosystem and other business applications. For a deeper understanding of what Power Automate can do, see our [Power Automate explainer](https://tallyfy.com/what-is-microsoft-flow-power-automate/). Think of it as the bridge that lets Tallyfy talk to your other systems - automating data flows and tasks between them. Here's the thing: Tallyfy remains your go-to platform for defining, managing, and tracking human-centric [processes](/products/pro/tracking-and-tasks/processes/). Power Automate complements this by handling the technical plumbing - those system-to-system integrations and automated tasks that happen around your Tallyfy workflows. Best part? You don't need extensive coding knowledge. | Use Power Automate for... | Use Tallyfy for... | |---------------------------|--------------------| | Data movement between systems | Human workflow management and [procedure templates](/products/pro/documenting/templates/) | | Automated system processes | Interactive [task](/products/pro/tracking-and-tasks/tasks/) assignment and tracking | | Technical integration focus | Business user experience and process visibility | | Event-triggered [automation](/products/pro/documenting/templates/automations/) rules | [process](/products/pro/tracking-and-tasks/processes/) standardization and improvement | | Backend system connectivity | Visual process tracking and collaboration | Why combine Power Automate with Tallyfy? Here are the payoffs: * **Data synchronization**: Keep information consistent between Tallyfy and other business systems. No more double entry. * **Automated triggers**: Start Tallyfy [processes](/products/pro/tracking-and-tasks/processes/) or [tasks](/products/pro/tracking-and-tasks/tasks/) when specific events happen in other applications - like magic. * **Microsoft ecosystem integration**: Connect Tallyfy with Office 365, SharePoint, Dynamics, and Teams. Your whole Microsoft stack plays nice together. * **[form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) data processing**: Take data submitted in Tallyfy [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) and use it in other systems automatically. * **Custom notifications**: Create sophisticated notification workflows based on Tallyfy events. Want a real example? When a candidate gets marked as "Hired" in your HR system, Power Automate can automatically kick off a Tallyfy "New Employee Onboarding" [procedure template](/products/pro/documenting/templates/). Or when someone completes a "Client Proposal" [task](/products/pro/tracking-and-tasks/tasks/) in Tallyfy, it updates your sales CRM instantly. That's the power of integration. For more perspective on how these platforms compare, check out these [insights on approvals workflows](https://tallyfy.com/integrations/using-microsoft-flow-for-approvals/). Keep in mind though - Tallyfy already has solid built-in approval capabilities. ## Your guide to using Power Automate with Tallyfy Ready to connect Power Automate with your Tallyfy Pro account? Our complete guide walks you through everything from the basics to advanced automations. You'll learn how to streamline your workflows and save hours of manual work. ## Key considerations when using Tallyfy with Power Automate * **Authentication**: You'll need to securely manage your Tallyfy connection in Power Automate. See [how to integrate Tallyfy with Microsoft Power Automate](/products/pro/integrations/middleware/power-automate/how-can-i-integrate-tallyfy-with-microsoft-power-automate/) for the exact setup steps. * **Tallyfy Connector**: Familiarize yourself with the triggers and actions available in the official [Tallyfy connector for Power Automate](/products/pro/integrations/middleware/power-automate/how-can-i-integrate-tallyfy-with-microsoft-power-automate/). It's your toolbox. * **Tallyfy API & Webhooks**: Need something the connector doesn't cover? Tallyfy's [Open API](/products/pro/integrations/open-api/) and [webhooks](/products/pro/integrations/webhooks/) work perfectly with Power Automate's HTTP request trigger/action. * **Error Handling**: Things go wrong sometimes. Set up error handling in your Power Automate flows to handle issues gracefully. Learn more about [managing and monitoring Power Automate flows](/products/pro/integrations/middleware/power-automate/managing-and-monitoring-power-automate-flows/). * **Performance and Limits**: Power Automate has flow execution limits. So does Tallyfy's API. Stay within these boundaries to keep your automations running smoothly. Power Automate extends Tallyfy Pro's capabilities significantly. You can create end-to-end automations that save time and eliminate tedious manual tasks. ### N8n - **[Common n8n workflow examples](https://tallyfy.com/products/pro/integrations/middleware/n8n/common-n8n-workflow-examples/)**: n8n workflows automate Tallyfy integrations by triggering process launches from CRM deals and form submissions while enabling parallel multi-system updates with intelligent AI-powered task routing and human-in-the-loop approval checkpoints ## Practical n8n workflows for Tallyfy automation Need ready-to-use n8n workflows that actually work? You're in the right place. These examples show common integration patterns with Tallyfy - complete with workflow structures and configuration details you can copy directly. ### Example 1: CRM to Tallyfy process automation Automatically [launch](/products/pro/launching/) a customer onboarding [process](/products/pro/tracking-and-tasks/processes/) when a deal is marked as "Won" in your CRM. **Workflow components:** 1. **Webhook node** (or CRM-specific trigger) - Receives notification when deal status changes - Filters for "Won" status only 2. **HTTP Request node** - Get customer details - Method: GET - URL: Your CRM API endpoint for customer data 3. **HTTP Request node** - Launch Tallyfy process - Method: POST - URL: `https://go.tallyfy.com/api/runs` - Body: ```json { "blueprint_id": "customer_onboarding_template_id", "name": "Onboarding - {{$json.customer_name}}", "kickoff": { "customer_name": "{{$json.customer_name}}", "email": "{{$json.email}}", "package": "{{$json.deal_type}}", "account_manager": "{{$json.assigned_to}}" } } ``` 4. **Slack node** (optional) - Send notification to sales team about process launch ### Example 2: Form submission to multi-system update Here's how to update multiple systems whenever someone submits a Tallyfy [form](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/). No manual copying required. **Workflow components:** 1. **Webhook node** - Configure in Tallyfy to trigger on task completion - Filter for specific form-containing tasks 2. **IF node** - Check task type - Condition: `{{$json.task.blueprint_step_id}} == "form_step_id"` 3. **Set node** - Extract form data - Map Tallyfy form fields to standardized variables 4. **HTTP Request node** - Update CRM - Method: PUT - URL: CRM contact endpoint - Map form fields to CRM fields 5. **Google Sheets node** - Log submission - Append row with form data and timestamp 6. **Email node** - Send confirmation - To: Form submitter - Include summary of submitted data ### Visualizing n8n workflow patterns This diagram shows how n8n workflows handle multi-system updates with conditional branching and retry logic. [Diagram removed for brevity] **What to notice:** - **Parallel processing branches** - The workflow updates CRM, Google Sheets, and sends emails simultaneously, reducing total execution time - **Exponential backoff retry pattern** - Failed operations retry with increasing wait times (2s, 4s, 8s) to avoid overwhelming systems - **Conditional path handling** - The IF node prevents processing tasks without forms, saving resources and preventing errors ### Example 3: Scheduled process launcher with data collection Want to launch weekly review processes that automatically gather data from your tools? This workflow does exactly that. **Workflow components:** 1. **Schedule Trigger node** - Cron expression: `0 9 * * 1` (Every Monday at 9 AM) 2. **HTTP Request node** - Get sales data - Connect to your analytics API - Fetch last week's metrics 3. **HTTP Request node** - Get support tickets - Query helpdesk API for open tickets 4. **Code node** - Process data ```javascript const salesTotal = items[0].json.total; const openTickets = items[1].json.count; const reviewData = { week_ending: new Date().toISOString().split('T')[0], sales_total: salesTotal, support_tickets: openTickets, review_priority: openTickets > 50 ? "High" : "Normal" }; return [{json: reviewData}]; ``` 5. **HTTP Request node** - Launch Tallyfy process - Method: POST - URL: `https://go.tallyfy.com/api/runs` - Include collected data in kickoff fields ### Example 4: Document generation from completed processes Need PDF reports when your Tallyfy processes finish? Here's a workflow that creates them automatically. **Workflow components:** 1. **Webhook node** - Tallyfy webhook for process completion 2. **HTTP Request node** - Get process details - Method: GET - URL: `https://go.tallyfy.com/api/runs/{{$json.run_id}}` 3. **HTTP Request node** - Get all task data - Method: GET - URL: `https://go.tallyfy.com/api/tasks?run_id={{$json.run_id}}` 4. **Code node** - Format report data ```javascript const tasks = $input.all(); const reportData = { process_name: tasks[0].json.run.name, completed_date: new Date().toISOString(), task_summary: tasks[1].json.map(task => ({ name: task.name, completed_by: task.completed_by_name, form_data: task.form_fields })) }; return [{json: reportData}]; ``` 5. **HTML node** - Generate HTML template - Create formatted report layout 6. **Convert to PDF node** (or external service) - Convert HTML to PDF 7. **Upload to cloud storage** - Store in Google Drive, Dropbox, or S3 ### Example 5: Intelligent task routing with AI Let AI analyze your Tallyfy form responses and route tasks to the right people. Your team gets the work they're best at - automatically. **Workflow components:** 1. **Webhook node** - Trigger on Tallyfy form submission 2. **OpenAI node** (or similar AI service) - Analyze form content for urgency and category - Prompt: "Categorize this request and assign priority" 3. **Switch node** - Route based on AI analysis - Branch for each category/priority combination 4. **HTTP Request node** (multiple) - Update task assignment - Method: PUT - URL: `https://go.tallyfy.com/api/tasks/{{$json.task_id}}` - Assign to appropriate Tallyfy [member](/products/pro/documenting/members/) based on routing 5. **Notification nodes** - Alert assigned team member via preferred channel ![n8n AI Agent node connected to OpenRouter Chat Model and Simple Memory for building intelligent workflow automations](https://screenshots.tallyfy.com/tallyfy/pro/n8n-ai-agent-setup.png) ### Example 6: Human-in-the-loop workflows Sometimes you need a human to review AI outputs or approve actions before they continue. n8n's "Send and wait for response" nodes let you pause workflows for human input - turning hours of manual review into quick approval checks. **Real-world pattern from production:** 1. **AI generates content** (proposal, report, blog post) 2. **Workflow pauses** with notification to Slack/Email asking for review 3. **Human reviews** and responds (approve/reject/modify) 4. **Workflow continues** based on the response **Workflow components:** 1. **Trigger node** - Start from webhook, schedule, or manual 2. **AI Agent node** - Generate the content that needs review - Configure with appropriate LLM (Claude, GPT-4, etc.) - Include clear system prompts for consistent output format 3. **Slack node** (Human in the Loop category) - Action: **Send message and wait for reply** - Send AI output with clear "Approve" / "Reject" / "Revise" instructions - Workflow pauses here until response received 4. **Switch node** - Route based on response - "Approved" → Continue to next action - "Rejected" → Log and notify, end workflow - "Revise" → Loop back to AI with feedback 5. **Action nodes** - Execute based on approval - Send proposal to client - Publish content - Update CRM records **Example use cases:** - **Review proposals before client delivery** - AI drafts, human verifies pricing and scope - **Approve AI-generated content before publishing** - Catch hallucinations or tone issues - **Validate data enrichment before CRM updates** - Confirm AI matched the right company **Pro tip**: You can stack multiple human-in-the-loop steps for multi-level approval workflows - just chain several "Send and wait" nodes with different reviewers. ### Switch nodes for intelligent routing The Switch node lets AI make decisions that branch your workflow into different paths. Instead of complex IF/ELSE chains, use AI classification combined with Switch routing. **Pattern:** ``` Webhook → AI Agent (classify request) → Switch Node → Multiple specialized paths ``` **How to configure:** 1. **AI Agent node** - Classify the input - System prompt: "Classify this request as exactly one of: URGENT, NORMAL, or LOW_PRIORITY" - Output should be a single keyword 2. **Switch node** - Create rules for each classification - Mode: **Rules** - Add rule: Value equals "URGENT" → Output 0 (urgent path) - Add rule: Value equals "NORMAL" → Output 1 (normal path) - Fallback: Output 2 (low priority path) 3. **Different paths** - Each output connects to specialized handling - URGENT: Immediate Slack alert + assign to senior staff - NORMAL: Standard queue + email notification - LOW_PRIORITY: Batch processing + weekly digest This pattern works for: - Customer support ticket triage - Lead scoring and routing - Content categorization - Compliance checking ### Best practices for n8n + Tallyfy workflows 1. **Error handling**: Your workflows will fail eventually - plan for it: ``` On Error: Continue (Error Output) → Log error details → Send alert notification → Store failed data for retry ``` 2. **Rate limiting**: Don't hammer the APIs. Add **Wait** nodes between bulk operations: - Wait 1 second between API calls when processing many items 3. **Data validation**: Check your data before sending it. Use **IF** nodes to validate: - Required fields actually exist - Data formats match what Tallyfy expects 4. **Workflow organization**: Future you will thank present you. Use **Sticky Note** nodes to document: - Workflow purpose and triggers - Required credentials and configuration - Expected data formats 5. **Testing approach**: - Start with **Manual Trigger** for testing - Add **Set** nodes with test data - Use **Stop and Error** nodes for debugging 6. **Retry settings for reliability**: Configure retry behavior in workflow settings: - Set retry count to 2+ for AI and HTTP nodes - Use 5000ms (5 seconds) between retry attempts - This handles temporary rate limits and network blips automatically 7. **Version history awareness**: n8n keeps workflow versions for 5 days: - Use **Export as JSON** for permanent backups of important workflows - You can restore previous versions from the workflow menu - Before major changes, export a backup JSON file ### Debugging tips | Issue | Solution | |-------|----------| | **Workflow not triggering** | Check webhook is active in both n8n and Tallyfy | | **Data not mapping correctly** | Use expression editor's "Current Node" tab to see available data | | **API errors** | Add HTTP Request "Full Response" option to see detailed errors | | **Performance issues** | Split large workflows into sub-workflows | ### Advanced patterns **Parallel processing**: Process multiple items at once (without breaking things). Use **Split In Batches** node to handle batches while respecting rate limits. **Retry logic**: Sometimes things fail. Here's smart retry with **Wait** and **IF** nodes: 1. Set retry counter 2. On error, increment counter 3. Wait exponentially longer between retries (2s, 4s, 8s...) 4. Stop after max retries reached **Data enrichment**: Need more context? Chain multiple API calls to gather complete data before launching Tallyfy processes. Perfect for pulling customer history, support tickets, or sales data into one complete picture. Ready to build? These examples give you working patterns to start from. Tweak them for your specific needs and systems. - **[Connecting n8n](https://tallyfy.com/products/pro/integrations/middleware/n8n/connecting-n8n-to-tallyfy/)**: n8n connects to Tallyfy through a dedicated community node or HTTP Request nodes enabling workflow automation with 60+ operations across blueprints processes tasks and users while supporting real-time webhook events and offering both self-hosted and cloud deployment options. ## Connect n8n to Tallyfy Connecting n8n to Tallyfy takes about 5 minutes now that we have a dedicated connector. You have two options: use our community-built Tallyfy node for instant setup, or use HTTP Request nodes for maximum flexibility. Both approaches work with Tallyfy's [Open API](/products/pro/integrations/open-api/) and handle authentication seamlessly. The dedicated connector covers most common use cases, while HTTP Request nodes give you complete control for advanced integrations. ### Integration architecture overview This diagram shows the two connection methods and the bidirectional flow between n8n and Tallyfy. [Diagram removed for brevity] **What to notice:** - The Tallyfy node provides instant setup for most use cases, while HTTP Request nodes offer complete flexibility for custom integrations - Both methods converge at the authentication test - if this fails, check your API token and permissions before proceeding - After successful connection, you gain access to many operations across multiple resources, with webhook support for real-time event handling ### Prerequisites Before starting, you'll need: - An active Tallyfy account with API access - n8n installed (self-hosted, cloud, or local development) - Your Tallyfy API key and Organization ID - For custom integrations: basic understanding of REST APIs ### Step 1: Get your Tallyfy API credentials :::warning[API Key Security] Treat your API key like a password. Never share it publicly or commit it to version control. In n8n, use the Credentials feature to store it securely. ::: ### Step 2: Set up Tallyfy credentials in n8n **Using the Tallyfy Node (Recommended)** **Alternative: HTTP Request Method** ### Step 3: Test your connection **Alternative test with HTTP Request:** - **Method**: GET, **URL**: `https://go.tallyfy.com/api/me` - Use your configured credential ### Step 4: Available operations in the Tallyfy node **Available resources and operations:** | Resource | Operations Available | Key Use Cases | |----------|---------------------|---------------| | **Blueprint** | Get, Get Many, Create, Update, Delete | Template management and process design | | **Process** | Launch, Get, Get Many, Update, Archive, Get Tasks | Process lifecycle and monitoring | | **Task** | Create One-Off, Complete, Get, Get Many, Update Properties, Delete, Clone | Task management and workflow control | | **Form Field** | Get Fields, Update Value (with guest access) | Dynamic data collection | | **Comment** | Create, Create Bot, Report Problem, Resolve Issue, Update, Delete | Communication and issue tracking | | **User** | Get Current, Get, Get Many, Invite, Update Role, Enable, Disable, Convert to Guest | Team management | | **Guest** | Create, Get, Get Many, Update, Delete, Convert to Member | External participant management | | **Group** | Create, Get, Get Many, Update, Delete | Team organization | | **Search** | Global, Tasks, Processes, Blueprints | Resource discovery | | **ID Finder** | Find Process/Task/Blueprint/Form Field/User/Group IDs | Resource identification utilities | **Key features:** - Built-in pagination handling ("Return All" option) - Automatic error handling and retry logic - Field validation and type checking - Support for dynamic field values using expressions ### Step 5: Launch a process using the Tallyfy node **Launch data tips:** - Field names must match your blueprint's kickoff form fields exactly - Use n8n expressions to map data from previous nodes - Support for text, numbers, dates, users, and file attachments - Leave optional fields empty - the node handles undefined values gracefully ### Step 6: Handle real-time updates with webhooks :::danger[Test vs Production URL - common mistake] When building workflows with webhooks, n8n provides two different URLs: a **Test URL** and a **Production URL**. The production URL only becomes active when you switch the workflow to "Active" status. Many users spend hours debugging because they: 1. Build and test with the Test URL 2. Switch the workflow to Active mode 3. Forget to update the URL in Tallyfy to the Production URL **Always update your webhook URLs in Tallyfy when going live.** The Test URL stops working once you activate the workflow. ::: **Real webhook payload structure:** ```json { "event": "task.completed", "organization_id": "org_123", "data": { "task_id": "task_456", "run_id": "run_789", "blueprint_id": "blueprint_abc", "user_id": "user_123", "completed_at": "2024-03-15T10:30:00Z", "form_data": { /* task form responses */ } } } ``` ### Webhook event flow This sequence diagram illustrates how Tallyfy sends real-time events to n8n with retry logic. [Diagram removed for brevity] **What to notice:** - Events are queued immediately when triggered (step 3), ensuring no events are lost even during high load - The retry mechanism uses exponential backoff (steps 8-10) to handle temporary network issues without overwhelming your n8n instance - Failed webhooks after 3 attempts trigger admin notifications (step 12) so you can investigate integration issues ### Debugging with the Executions panel The Executions panel is one of n8n's most powerful features for debugging workflows. Every time a workflow runs - whether in test or production - n8n records the complete execution with input and output data at each node. ![n8n workflow canvas showing multiple trigger types including Webhook, Chat message, Schedule Trigger, and Execute Workflow nodes](https://screenshots.tallyfy.com/tallyfy/pro/n8n-workflow-canvas-triggers.png) **Viewing execution history:** - Click **Executions** tab at the top of the workflow editor - Each execution shows status (success/error), timing, and trigger source - Click any execution to see the data that flowed through each node - Use filters to find specific executions by date or status **Data Pinning - skip expensive operations during testing:** When building complex workflows with AI agents or external API calls, re-running every node each time you test is slow and expensive. Data Pinning lets you "freeze" a node's output so it's reused in subsequent test runs. To pin data: 1. Run your workflow to get real data through the nodes 2. Click on any node that has output data 3. Click the **Pin** icon to lock that output 4. Now when you test, n8n skips that node and uses the pinned data instead This is particularly useful when: - Testing AI agent workflows (avoid repeated LLM calls) - Debugging nodes downstream of slow API calls - Developing with rate-limited external services **Copy execution to editor:** If a production execution fails or produces unexpected results, you can load that exact execution back into the editor to debug: 1. Find the problematic execution in the Executions panel 2. Click the three-dot menu and select **Copy to Editor** 3. The workflow opens with all the original input data loaded 4. Test individual nodes or modify and re-run ### Troubleshooting guide | Issue | Cause | Solution | |-------|-------|----------| | **401 Unauthorized** | Invalid or expired token | Regenerate API token in Tallyfy settings | | **403 Forbidden** | Insufficient permissions | Check user role allows API access | | **404 Not Found** | Wrong endpoint or missing resource | Verify Organization ID and resource IDs | | **422 Unprocessable Entity** | Invalid data format | Check required fields and data types | | **Rate limiting (429)** | Too many requests | Add 1-2 second delays between calls | | **Connection timeout** | Network or server issues | Add retry logic with exponential backoff | | **Webhook not receiving data** | URL or events misconfigured | Verify webhook URL and selected events | | **Webhook works in test but not production** | Using Test URL instead of Production URL | Update Tallyfy to use Production URL after activating workflow | | **AI node timing out during development** | Re-running expensive operations | Use Data Pinning to cache AI outputs while building | **Advanced debugging:** - Enable **Retry on Failure** in node settings - Use **Split in Batches** for processing large datasets - Add **Function** nodes to log request/response data - Test authentication with the `/me` endpoint first ### Security and performance best practices **Security:** - Store API tokens in n8n credentials, never in code - Use webhook secrets to verify payload authenticity - Rotate API tokens quarterly or after team changes - Enable n8n's IP whitelist for production environments **Performance and reliability:** - Use **Split in Batches** for processing 50+ items - Add 500ms delays between API calls to avoid rate limits - Enable **Retry on Failure** with exponential backoff - Set appropriate timeouts (30s for complex operations) **Monitoring and maintenance:** - Add error notifications via email or Slack - Log important workflow events for debugging - Test critical workflows monthly with sample data - Monitor n8n execution metrics and set alerts **Data handling:** - Use pagination for large datasets (Tallyfy returns 25 items by default) - Validate required fields before sending API requests - Handle edge cases like missing users or archived processes - Cache frequently accessed data to reduce API calls ### Advanced integration patterns Once connected, you can build sophisticated automations: **AI-enhanced workflows:** - Analyze form responses with AI and route processes accordingly - Generate process summaries and executive reports using LLMs - Automatically categorize and prioritize incoming requests **Multi-system orchestration:** - Launch Tallyfy processes from CRM deal updates - Sync completed tasks back to project management tools - Create approval workflows spanning multiple platforms **Real-time business intelligence:** - Stream process metrics to BI dashboards - Send alerts when SLAs are at risk - Generate compliance reports automatically Explore the workflow examples below to see these patterns in action. - **[n8n vs other middleware platforms](https://tallyfy.com/products/pro/integrations/middleware/n8n/n8n-vs-other-middleware-platforms/)**: n8n offers execution-based pricing and self-hosting options that make it cost-effective for high-volume Tallyfy integrations compared to task-based platforms like Zapier while providing full code flexibility and data privacy control for organizations with technical resources and compliance requirements. ## Choosing the right middleware platform for Tallyfy Picking the right [middleware](/products/pro/integrations/middleware/) platform can make or break your Tallyfy integrations. Your choice affects everything - automation power, monthly costs, and how much control you have. Let's compare n8n with other popular platforms to help you decide. ### Quick comparison table | Feature | n8n | Zapier | Make | Power Automate | |---------|-----|--------|------|----------------| | **Pricing model** | Per workflow execution | Per task/operation | Per operation | Per user/flow run | | **Self-hosting** | ✅ Yes | ❌ No | ❌ No | ❌ No | | **Visual builder** | ✅ Yes | ✅ Yes | ✅ Yes | ✅ Yes | | **Code flexibility** | ✅ Full JS/Python | ⚠️ Limited | ⚠️ Limited | ⚠️ Limited | | **Tallyfy connector** | ❌ Use HTTP | ✅ Native | ❌ Use HTTP | ✅ Native | | **Learning curve** | Medium | Easy | Medium | Medium-Hard | | **Error handling** | ✅ Advanced | ⚠️ Basic | ✅ Good | ✅ Good | | **Free tier** | ✅ Self-host unlimited | ⚠️ Limited | ⚠️ Limited | ⚠️ Limited | ### n8n strengths for Tallyfy integration **Cost efficiency at scale**: Here's the thing - n8n charges per workflow execution, not per operation. Check 100 Tallyfy [tasks](/products/pro/tracking-and-tasks/tasks/)? That's one execution in n8n. Other platforms? That's 100 operations. You do the math. **Data privacy and compliance**: Self-hosting n8n means your Tallyfy data stays on your servers. Period. For organizations with strict [compliance](/products/pro/compliance/) requirements, this is non-negotiable. **Developer-friendly features**: - Write custom JavaScript or Python code within workflows - Debug with step-by-step execution viewer - Version control integration for workflow definitions - API-first design matches Tallyfy's approach **No vendor lock-in**: Export workflows as JSON. Switch instances. Modify programmatically. Your workflows, your control. ### When to choose n8n over alternatives Choose n8n when you have: 1. **High-volume integrations**: Processing hundreds of Tallyfy tasks or launching dozens of processes daily 2. **Complex data transformations**: Need to reshape data between Tallyfy and other systems 3. **Security requirements**: Integration data can't leave your servers 4. **Technical resources**: Your team can handle basic API concepts 5. **Budget constraints**: Can't afford per-operation pricing that adds up fast 6. **AI workflow flexibility**: Need to switch between AI models (Claude, GPT-4, Llama) without rebuilding workflows 7. **Healthcare/HIPAA compliance**: Need self-hosted deployment for PHI data handling - n8n Cloud's standard tiers can't provide BAA ### When other platforms might be better **Choose Zapier when:** - You need something up and running in 5 minutes - You're only connecting a few simple workflows - You prefer native Tallyfy connector over API configuration - Budget isn't a primary concern for low-volume use **Choose Make when:** - You need visual data mapping tools - You want a balance between ease and power - You're building moderately complex multi-step workflows - You prefer cloud-only solutions **Choose Power Automate when:** - Your organization already uses Microsoft 365 everywhere - You need desktop automation alongside web integrations - You want to use Microsoft's AI Builder - You have Power Platform licenses already ### Cost considerations When evaluating costs, consider these factors: **Scenario**: Daily sync of 50 Tallyfy processes, each with 10 tasks to check and potentially update across your CRM and project management tools. - **n8n Self-hosted**: No subscription fees, only infrastructure costs - **n8n Cloud**: Execution-based pricing - **Zapier**: Task-based pricing - each operation counts - **Make**: Operation-based pricing - **Power Automate**: Flow run or per-user licensing options Check each platform's current pricing page for accurate rates, as pricing models and tiers change frequently. **Cost-saving tip - test executions:** n8n's test workflow executions don't count toward your operation quota. This means you can: - Process 10,000 records through a test workflow during development without using any paid operations - Debug complex data transformations at scale before going live - Run quality checks on large datasets without burning through your allocation This is particularly useful when building Tallyfy integrations that process bulk data - test your logic thoroughly without cost concerns, then switch to production when ready. ### Integration complexity comparison **Simple integration** (Launch process from form): - **Zapier**: 5 minutes with native connector - **n8n**: 10 minutes with HTTP Request node - **Make**: 10 minutes with HTTP module - **Power Automate**: 8 minutes with connector **Complex integration** (Multi-system data collection before process launch): - **Zapier**: Gets messy with linear flow - you'll need multiple zaps - **n8n**: Full control with branching, loops, and custom code - **Make**: Good visual tools but limited code options - **Power Automate**: Capable but complex interface ### Feature-specific considerations **Debugging and monitoring**: - n8n: Excellent execution history with full data visibility - Zapier: Basic task history - Make: Good execution logs with data flow visualization - Power Automate: Detailed run history with analytics **Team collaboration**: - n8n: Self-hosted requires own user management - Zapier: Built-in team features with permissions - Make: Team workspaces with role management - Power Automate: Integrated with Microsoft 365 permissions **Webhook handling**: - n8n: Unlimited webhooks with any plan - Zapier: Webhooks on paid plans only - Make: Webhooks available on all plans - Power Automate: Full webhook support ### Migration considerations Thinking about switching to n8n? Here's what you're looking at: 1. **Workflow recreation**: Can't import directly, but n8n's flexibility often makes complex workarounds simpler 2. **Credential setup**: One-time configuration of HTTP Request credentials for Tallyfy 3. **Testing period**: Run both platforms side-by-side for a week or two 4. **Training needs**: Your team needs basic API understanding (nothing crazy) ### Hybrid approach Some organizations use multiple platforms: - **Zapier** for simple, non-technical team workflows - **n8n** for complex, high-volume, or sensitive integrations - **Power Automate** for Microsoft-specific connections Smart move? Sometimes. ### Making your decision Consider these factors: 1. **Volume**: Processing tons of tasks? n8n's execution-based pricing wins 2. **Complexity**: Need complex logic? n8n's code support makes it manageable 3. **Security**: Must self-host? That's n8n 4. **Team skills**: Not technical? Zapier might be easier 5. **Existing tools**: Already in Microsoft's ecosystem? Power Automate fits naturally 6. **Budget**: Compare total cost of ownership for your expected volume With n8n's HTTP Request node connecting directly to Tallyfy's [Open API](/products/pro/integrations/open-api/), you're never stuck waiting for connector updates. Growing fast? n8n grows with you. ### Workato - **[Complete Tallyfy tasks from Workato](https://tallyfy.com/products/pro/integrations/middleware/workato/how-to-complete-tallyfy-tasks-from-workato/)**: Workato recipes can programmatically complete Tallyfy tasks by using HTTP PUT requests to the task completion endpoint with proper authentication and form field data allowing seamless cross-platform automation when events occur in systems like DocuSign or CRM platforms. ## Automatically complete Tallyfy tasks using Workato Want to complete [Tallyfy tasks](/products/pro/tracking-and-tasks/tasks/) programmatically from your Workato recipes? You can trigger task updates based on events in other systems - perfect for creating seamless cross-platform workflows. ### Common use cases - Mark Tallyfy tasks complete when a document is signed in DocuSign - Complete approval tasks based on responses in Microsoft Forms - Update Tallyfy task form fields when data changes in your CRM - Auto-complete tasks when specific conditions are met in your ERP ### Prerequisites - Workato account with HTTP connector access - Tallyfy API token from **Settings > Integrations > REST API** - Task IDs or a method to retrieve them dynamically - Understanding of your task's [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) ## Setting up task completion ### Step 1: Identify the Tallyfy task to complete You'll need the task ID to complete it. Here's how to get it: #### Option A: From a Tallyfy webhook If Tallyfy triggered your Workato recipe via webhook: ```ruby task_id = trigger["task"]["id"] ``` #### Option B: Search for tasks by process Use an HTTP GET request to find tasks: ``` GET https://go.tallyfy.com/api/tasks?run_id={process_id} ``` #### Option C: Store task IDs When launching processes, store the returned task IDs in a lookup table or database. Works great for recurring workflows. ### Step 2: Configure the completion request ### Step 3: Handle form fields If the task has form fields that need values, include them in the request body: ```json { "form_fields": { "approval_status": "Approved", "approver_name": "John Smith", "approval_date": "2025-01-15", "comments": "Looks good, approved for implementation" } } ``` #### Dynamic field mapping Map fields from your trigger data: ```ruby { "form_fields": { "invoice_number": trigger["invoice"]["number"], "amount": trigger["invoice"]["total"], "payment_status": trigger["payment"]["status"], "processed_by": trigger["user"]["email"] } } ``` ## Advanced completion scenarios ### Conditional task completion Need to complete tasks only when specific conditions are met? Easy. ### Bulk task completion Got multiple tasks to complete in a process? Here's the pattern: ### Updating without completing Sometimes you just want to update form fields without marking the task complete - maybe you're collecting data incrementally: ``` PUT https://go.tallyfy.com/api/tasks/{task_id} ``` Request body: ```json { "captures": { "field_name": "updated_value", "status": "In Progress" } } ``` ## Error handling strategies ### Common errors and solutions | Error Code | Meaning | Solution | |------------|---------|----------| | 401 | Unauthorized | Check API token and headers | | 404 | Task not found | Verify task ID and that it exists | | 400 | Invalid data | Check form field names and data types | | 422 | Validation failed | Ensure required fields are provided | ### Implementing retry logic ## Recipe example: Complete task on document signature Let's walk through a real-world recipe pattern: ## Best practices ### Performance optimization - Cache frequently used task IDs to reduce API calls - Use batch operations when possible - Implement connection pooling for high-volume scenarios - Monitor API usage against rate limits ### Data integrity - Validate data before sending to Tallyfy - Log all completions for audit trails - Implement rollback mechanisms for critical workflows - Use idempotency keys to prevent duplicate completions ### Security considerations - Never expose API tokens in logs - Use Workato's secure storage for credentials - Implement field-level encryption for sensitive data - Audit recipe access regularly ## Troubleshooting guide ### Tallyfy task not completing? Here's the troubleshooting checklist: 1. Verify the task is in "active" status 2. Check all required form fields are provided 3. Ensure the assigned user has permission 4. Confirm the task hasn't already been completed ### Form data not saving? The culprit is usually one of these: 1. Field names must match exactly (case-sensitive) 2. Check data types (string vs number vs boolean) 3. Verify field exists in the task template 4. Ensure values meet field validation rules ### Getting 429 rate limit errors? You're hitting our API too fast. Fix it with: 1. Add delays between requests 2. Implement exponential backoff 3. Batch operations where possible 4. Contact Tallyfy support for higher limits if needed ## Next steps Ready to level up your integration? Consider these improvements: - Set up Tallyfy webhooks to trigger completions in real-time - Create reusable functions for common operations - Build error notification workflows - Implement detailed logging and monitoring - **[Launch Tallyfy processes from Workato](https://tallyfy.com/products/pro/integrations/middleware/workato/how-to-launch-tallyfy-processes-from-workato/)**: This guide explains how to connect Workato to Tallyfy's API using the HTTP connector to automatically launch workflow processes based on events from external systems like Salesforce or Zendesk by configuring authentication headers and mapping trigger data to kick-off form fields through the prerun object. ## Automatically launch Tallyfy processes from Workato recipes Want to launch Tallyfy workflows when something happens in Salesforce? Or maybe when a support ticket comes in? You can connect Workato to Tallyfy using the HTTP connector to automatically start [processes](/products/pro/tracking-and-tasks/processes/) based on events in your other business systems - whether that's your CRM, ERP, or help desk. ### Integration flow overview This diagram shows how external triggers flow through Workato to launch Tallyfy processes automatically. [Diagram removed for brevity] **What to notice:** - The authentication setup (step 4) requires both a Bearer token and the X-Tallyfy-Client header - missing either will cause a 401 error - Workato transforms trigger data into the prerun object that populates your kick-off form fields automatically (step 2) - Error handling (step 8) captures any issues with authentication, template ID, data format, or rate limits ### Prerequisites Before you begin, make sure you have: - A Workato account with HTTP connector access - A Tallyfy account with API access enabled - Your Tallyfy API token from **Settings > Integrations > REST API** - The template ID of the Tallyfy process you want to launch - The user ID who will own the launched processes ### Step 1: Create the HTTP connection in Workato ### Step 2: Create a recipe to launch processes ### Step 3: Configure the request body Here's where you tell Tallyfy what process to launch and with what data. You'll need JSON in the **Request body** field: ```json { "blueprint_id": "YOUR_TEMPLATE_ID", "title": "Process title from trigger data", "owner_id": "USER_ID", "organization_id": "YOUR_ORG_ID", "prerun": { "field1_name": "value from trigger", "field2_name": "another value" } } ``` #### Mapping dynamic data Real power comes from using data from your trigger. Instead of hardcoding values: 1. Click the **Formula** mode toggle 2. Build your JSON dynamically: ```ruby { "blueprint_id": "abc123", "title": "Order " + trigger["order_number"] + " - " + trigger["customer_name"], "owner_id": "user456", "organization_id": "org789", "prerun": { "customer_name": trigger["customer_name"], "order_value": trigger["total_amount"], "priority": trigger["priority"] } } ``` ### Step 4: Handle kick-off form fields Got a [kick-off form](/products/pro/launching/triggers/kick-off-forms/) in your template? You'll populate those fields through the `prerun` object. It's straightforward: 1. Identify all required kick-off form fields in your template 2. Map each field in the `prerun` section 3. Ensure data types match (text, number, date, etc.) Here's an example with different field types: ```json { "blueprint_id": "template123", "title": "New Employee: John Smith", "owner_id": "hr_manager_id", "prerun": { "employee_name": "John Smith", "start_date": "YYYY-MM-DD", "department": "Engineering", "salary": 75000, "remote_worker": true, "equipment_needed": ["Laptop", "Monitor", "Headset"] } } ``` ### Step 5: Process the Tallyfy response Once Tallyfy launches your process, it sends back details you can use: ### Step 6: Add error handling ### Common integration patterns #### Pattern 1: Launch from CRM opportunity Picture this - a Salesforce opportunity hits "Closed Won" and your onboarding kicks off automatically: 1. Trigger: Salesforce - Updated opportunity 2. Condition: Status changed to "Closed Won" 3. Action: Launch Tallyfy customer onboarding process 4. Pass opportunity data to kick-off form #### Pattern 2: Launch from support ticket When urgent tickets need immediate attention: 1. Trigger: Zendesk - New ticket 2. Condition: Priority = "Urgent" 3. Action: Launch Tallyfy escalation process 4. Assign to on-call manager #### Pattern 3: Scheduled launches Perfect for monthly reports or weekly reviews: 1. Trigger: Scheduler - Daily/Weekly/Monthly 2. Action: Launch Tallyfy process 3. Use date formulas for dynamic titles ### Troubleshooting tips #### Tallyfy process not launching? Here's what to check: - Verify your Tallyfy API token is active and has proper permissions - Check that `X-Tallyfy-Client: APIClient` header is included - Ensure the Tallyfy template ID is correct (not the template name) - Confirm user ID exists and is active #### Kick-off form data not appearing? The usual suspects: - Field names in `prerun` must match exactly (case-sensitive) - Check data types match field expectations - Required fields must have values #### Rate limit errors? You're hitting Tallyfy's API limits (100 requests per minute). Try these fixes: - Add delays between bulk launches - Implement exponential backoff for retries - Space out your requests over time ### Next steps Got your integration working? Time to level up: - Set up webhooks to get notified when tasks complete - Create recipes to update processes based on external events - Build dashboards to track launched processes - Implement two-way sync between systems ### Zapier - **[Tallyfy and Zapier](https://tallyfy.com/products/pro/integrations/middleware/zapier/how-can-i-improve-task-management-with-tallyfy/)**: Tallyfy integrates with Zapier to combine human-centric task management with automated workflows enabling CRM-triggered onboarding scheduled process execution communication-based task creation and web form tracking across thousands of business applications. ## Improve task management with Tallyfy and Zapier Tallyfy handles the human side of [process](/products/pro/tracking-and-tasks/processes/) management - the parts that need judgment, creativity, and decision-making. Zapier handles the robotic stuff. Together, they connect your existing business applications without forcing everything into rigid automation. Here's what you get: a workflow platform that knows when to automate and when to keep humans in control. Your team completes [tasks](/products/pro/tracking-and-tasks/tasks/) that matter while [integrations](/products/pro/integrations/) handle the repetitive grunt work. :::note[Considering Integration Alternatives] While Zapier works fine for simple connections, you'll want more powerful [middleware](/products/pro/integrations/middleware/) solutions like **n8n**, **Make**, or **Microsoft Power Automate** for serious integrations. They cost less too. Got developers? Tallyfy's [Open API](/products/pro/integrations/open-api/) gives you total control. You can even use AI to generate integration code for serverless functions (yes, it actually works). ::: ### What unique value does Tallyfy provide compared to automation-only solutions? Pure automation platforms can't handle what humans do best - think, judge, and adapt. Tallyfy fills that gap: - **Human-centric workflows** - [Processes](/products/pro/tracking-and-tasks/processes/) built around people completing [tasks](/products/pro/tracking-and-tasks/tasks/), not robots - **Structured task management** - Work flows in logical order, not chaos - **Process accountability** - You know exactly who's responsible for what - **Cross-application [integration](/products/pro/integrations/)** - Human decisions trigger automated actions across your tech stack - **Complete workflow coverage** - From initial documentation through final automation ### Key integration use cases Want to see this in action? Zapier connects Tallyfy with thousands of applications. Here are the patterns that actually work: #### 1. CRM-triggered onboarding Deal closes in your CRM. What happens next? - Tallyfy instantly [launches](/products/pro/launching/) your client onboarding [process](/products/pro/tracking-and-tasks/processes/) - The right team [members](/products/pro/documenting/members/) get their tasks assigned automatically - Everyone sees progress in real-time - no more "what's the status?" emails #### 2. Scheduled process execution Got weekly reports? Monthly audits? Quarterly reviews? - Set up time-based triggers in Zapier (takes 2 minutes) - Tallyfy [launches](/products/pro/launching/) your [processes](/products/pro/tracking-and-tasks/processes/) exactly when needed - Never miss another recurring task again #### 3. Communication-based task creation Stop losing important requests in email and Slack: - Send an email to support@yourcompany.com? It becomes a [task](/products/pro/tracking-and-tasks/tasks/) in Tallyfy - Type #urgent in Slack? A new [process](/products/pro/tracking-and-tasks/processes/) kicks off automatically - Nothing falls through the cracks anymore #### 4. Web form process tracking Customer fills out your web form. Then what? - Form data flows straight into Tallyfy - The right [process](/products/pro/tracking-and-tasks/processes/) [launches](/products/pro/launching/) based on the request type - You track everything from "submitted" to "done" - full visibility ### Implementation resources Ready to build these integrations? Start here: - [Connect your Tallyfy account to Zapier](/products/pro/integrations/middleware/zapier/how-to-connect-your-tallyfy-account-to-zapier/) - Get connected in under 5 minutes - [Launch a Tallyfy Process with Zapier](/products/pro/integrations/middleware/zapier/how-to-customize-your-tallyfy-zap-for-launch-process/) - Your first automated process, step by step - **[Automate monthly process launch with Zapier](https://tallyfy.com/products/pro/integrations/middleware/zapier/how-to-automate-monthly-process-launch-with-zapier/)**: Tallyfy processes can be automatically launched monthly using Zapier's scheduler by setting up a schedule trigger connected to the Launch Process action which takes about 5 minutes to configure and eliminates manual workflow initiation. ## Automate monthly process launches with Zapier You can set up Tallyfy to automatically launch [processes](/products/pro/tracking-and-tasks/processes/) every month without lifting a finger. It takes about 5 minutes to configure. Here's how to set up automatic [process launches](/products/pro/launching/) on the first day of each month using Zapier's scheduler. Once configured, your workflows run like clockwork - no more forgetting to start that monthly reporting process or employee review cycle. :::note[Why consider alternative integration platforms?] Zapier works well for basic connections, but we actually recommend [middleware](/products/pro/integrations/middleware/) platforms like **n8n**, **Make**, or **Microsoft Power Automate** for business-critical integrations. They're more powerful and won't break the bank. Got developers on your team? Consider using Tallyfy's [Open API](/products/pro/integrations/open-api/) to build custom integrations. You can even use AI to help generate the code for serverless functions (yes, it's that straightforward). ::: Ready? Let's walk through the setup: - **[Automate tasks using Zapier](https://tallyfy.com/products/pro/integrations/middleware/zapier/how-to-automate-tasks-in-tallyfy-using-zaps/)**: This guide explains how to automate Tallyfy task completion through Zapier by either using an existing task ID or first finding the task via template and process name then marking it complete through the API. ## Automate task completion using Zaps You can automate [tasks](/products/pro/tracking-and-tasks/tasks/) in Tallyfy through Zapier - and this guide shows you exactly how. The same approach works with other [middleware](/products/pro/integrations/middleware/) platforms like Power Automate too. Why bother with automation? It cuts out manual steps, speeds up your workflows, and keeps everything running smoothly across your connected apps. ## Automation flow overview This diagram shows how Zapier connects external triggers to Tallyfy task completion through two possible paths. [Diagram removed for brevity] **What to notice:** - The flow branches based on whether you already have the task ID - if not, you'll need to find it first - Finding a task requires both the template ID and a search method (either process name or kick-off field value) - Both paths converge at the final action where the task gets marked complete through Tallyfy's API :::note[Considering Integration Alternatives] While Zapier can be useful for simple connections, we generally recommend more capable and cost-effective [middleware](/products/pro/integrations/middleware/) solutions like **n8n**, **Make**, or **Microsoft Power Automate** for serious integrations. For maximum control and flexibility, especially if you have development resources, consider using Tallyfy's [Open API](/products/pro/integrations/open-api/) to build custom integrations, potentially using AI to generate code for serverless functions. ::: First things first - pick a trigger that lets you send custom data, like a process name. Got the [task](/products/pro/tracking-and-tasks/tasks/) ID already? Great, jump ahead to completing the task. If not, here's how to find it: Found your [process](/products/pro/tracking-and-tasks/processes/)? Perfect. Here's how to complete the [task](/products/pro/tracking-and-tasks/tasks/): Want to see this in action? Watch how to set up a zap that marks a [process task](/products/pro/tracking-and-tasks/tasks/) complete: Quick heads-up: Testing a zap that completes a [task](/products/pro/tracking-and-tasks/tasks/)? You'll need to manually re-open that task in Tallyfy afterwards. - **[Connect Tallyfy to Zapier](https://tallyfy.com/products/pro/integrations/middleware/zapier/how-to-connect-your-tallyfy-account-to-zapier/)**: Connecting Tallyfy to Zapier requires obtaining your Organization ID from Tallyfy settings and then authorizing the connection in Zapier by entering your credentials to enable automated workflows between Tallyfy and other business applications. ## Connect your Tallyfy account to Zapier You'll need to set up secure authentication between Tallyfy and Zapier to get them talking to each other. Takes about 5 minutes. Here's exactly how to create that connection - once it's done, you can automate workflows between Tallyfy and literally thousands of other apps through Zapier. :::note[Considering Integration Alternatives] While Zapier can be useful for simple connections, we generally recommend more capable and cost-effective [middleware](/products/pro/integrations/middleware/) solutions like **n8n**, **Make**, or **Microsoft Power Automate** for serious integrations. For maximum control and flexibility, especially if you have development resources, consider using Tallyfy's [Open API](/products/pro/integrations/open-api/) to build custom integrations, potentially using AI to generate code for serverless functions. ::: ### Requirements What you'll need: - An active Tallyfy account with administrative access - A Zapier account (free or paid plan) - Permission to create [integrations](/products/pro/integrations/) for your organization ### Connection process #### Step 1: Obtain your Tallyfy Organization ID #### Step 2: Connect your account in Zapier #### Step 3: Verify the connection ### Troubleshooting Connection not working? Check these things: - Verify your Organization ID is correctly copied - Make sure you're using the right Tallyfy login credentials - Check that your Tallyfy account has the necessary permissions - Still stuck? [Contact Tallyfy support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/) for help Once connected, you're ready to create Zaps that automate workflows between Tallyfy and your other business applications. - **[Action to 'Launch Process'](https://tallyfy.com/products/pro/integrations/middleware/zapier/how-to-customize-your-tallyfy-zap-for-launch-process/)**: This guide explains how to customize Zapier integrations with Tallyfy for launching processes using triggers from apps like Google Forms or CRMs while noting that custom Zap entries override template settings and that blank assignee fields will assign all tasks to the Zapier account owner rather than inheriting from the template configuration. ## How to customize your Zap for launching Tallyfy processes This guide shows you how to customize your Zap to [launch a process](/products/pro/launching/) in Tallyfy. ### Common CRM automation examples **Automate client onboarding from your CRM:** 1. **Trigger**: New contact marked "Onboard as client" in CRM (Salesforce, HubSpot, etc.) 2. **Action**: Launch Tallyfy onboarding process with client data pre-filled 3. **Result**: Automatic task assignments, welcome emails, and setup workflows **Sales-to-delivery handoff:** 1. **Trigger**: Deal marked "Closed Won" in CRM 2. **Action**: Launch implementation process in Tallyfy 3. **Data passed**: Client details, project scope, delivery timeline 4. **Result**: Seamless transition from sales to delivery team **Support ticket escalation:** 1. **Trigger**: High-priority ticket created in help desk 2. **Action**: Launch incident response process 3. **Auto-assignments**: Based on ticket type and severity 4. **Result**: Immediate response workflow with proper stakeholders :::note[Considering Integration Alternatives] While Zapier can be useful for simple connections, we generally recommend more capable and cost-effective [middleware](/products/pro/integrations/middleware/) solutions like **n8n**, **Make**, or **Microsoft Power Automate** for serious integrations. For maximum control and flexibility, especially if you have development resources, consider using Tallyfy's [Open API](/products/pro/integrations/open-api/) to build custom integrations, potentially using AI to generate code for serverless functions. ::: :::note[Note on zapier dates] Please note that Zapier does not support natural language dates like 2 days, 2d or 5 weeks. That means, a deadline modifier like `-2d` appended to a date will throw an error. ::: ### Please note Custom entries assigned in the Zap will override [template](/products/pro/documenting/templates/) level attributes such as assignees, deadlines, [form](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) values etc. :::caution[Critical assignment behavior difference] **Assignees and deadlines behave differently when left blank**: - **Deadlines**: When left blank, inherit from template configuration ✅ - **Assignees**: When left blank, ALL tasks are assigned to the Zapier account owner, NOT the template assignees ❌ This means if you don't explicitly set assignees in your Zap configuration, every task will be assigned to whoever owns the Zapier connection, regardless of your template settings. **Solutions**: 1. **Explicitly set assignees** in your Zap configuration for each step 2. **Use automation rules** as a workaround - create a template automation that triggers on kick-off form completion to reassign tasks to the correct people/groups 3. **Search for groups** - You can search for and assign groups directly in Zapier **Best practice**: Always configure assignees explicitly in your Zap to ensure tasks go to the right people. ::: :::note[A note on passing checklist items through to the zap] When you need to fill out a checklist when [launching a process](/products/pro/launching/) via your Zap - ensure you use a comma-separated set of values from the original source, and then pass that straight through to the checklist. The result will be intuitive - the items you passed in will be the values which are "checked" in your checklist [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/). ::: - **[Troubleshooting Tallyfy-Zapier integration issues](https://tallyfy.com/products/pro/integrations/middleware/zapier/zapier-integration-troubleshooting/)**: Tallyfy-Zapier integration problems can be resolved through systematic troubleshooting of authentication credentials connection settings webhook configurations trigger mappings and field formatting while following best practices for reliable workflow automation between applications. ## Diagnose and fix Tallyfy-Zapier problems The Tallyfy-Zapier integration enables connections between Tallyfy and thousands of business applications, automating workflows across your entire technology stack. Occasional integration challenges may arise that require systematic troubleshooting approaches. This guide helps identify, diagnose, and resolve common Zapier integration problems, ensuring reliable workflow automation between Tallyfy and connected applications. ### Understanding Tallyfy's webhook-based Zapier integration :::caution[Webhooks vs traditional Zapier triggers] Tallyfy uses **webhooks** to send data to Zapier, not traditional polling-based triggers. - **Instant updates**: Webhooks fire immediately when events occur (no 5-15 minute polling delays) - **More reliable**: Direct push notifications instead of periodic checking - **Better performance**: No wasted API calls checking for changes - **Same Zapier experience**: Once configured, webhooks work exactly like regular Zapier triggers To competitors evaluating Tallyfy: Our webhook approach provides superior real-time integration compared to traditional polling triggers. ::: ### Resolve connection issues Connection problems between Tallyfy and Zapier typically stem from authentication, permission, or configuration challenges that can be systematically resolved: #### What authentication problems occur with Tallyfy-Zapier connections? - **Invalid credentials**: Verify correct Tallyfy email address and password combinations are being used for authentication - **Access permissions**: Confirm your Tallyfy account possesses administrator or standard member permissions required for integration access - **Token expiration**: Reconnect your Tallyfy account within Zapier when authentication tokens expire or become invalid #### Connection setup issues 1. **Can't find Tallyfy app in Zapier**: - Search for "Tallyfy" in the Zapier app directory - Ensure you're using the correct spelling - If still not visible, try navigating directly to [zapier.com/apps/tallyfy](https://zapier.com/apps/tallyfy) 2. **Connection timeout errors**: - Check your internet connection - Try connecting during non-peak hours - Contact Tallyfy support if the issue persists ### Trigger issues Problems with Zapier triggers not firing when expected: #### "New Task" trigger not working - **Check webhook status**: Ensure webhooks are properly configured in Tallyfy - **Verify task creation**: Confirm tasks are being created correctly in Tallyfy - **Filter settings**: Check if you have filters that might be preventing the trigger from firing #### "Task Completed" trigger not firing - **Task status**: Verify the task was actually marked as complete in Tallyfy - **Zap status**: Ensure your Zap is turned on in Zapier - **Time delay**: Allow a few minutes for the trigger to process #### "Process Launched" trigger issues - **Launch confirmation**: Confirm the process was successfully launched in Tallyfy - **Template changes**: Check if the process template has been modified recently - **Permission issues**: Ensure the connected account has visibility to the launched process ### Action issues Problems when Zapier tries to perform actions in Tallyfy: #### "Launch Process" action failing - **Template availability**: Verify the template ID exists and is active - **Required fields**: Ensure all required launch parameters are provided - **Formatting issues**: Check that dates and other special fields use the correct format #### "Create Task" action not working - **Assignment issues**: Confirm the assignee exists in Tallyfy - **Field mapping**: Verify all required fields are properly mapped - **Permission problems**: Ensure the connected account has permission to create tasks #### Data mapping problems - **Field type mismatch**: Ensure the data types match between Zapier and Tallyfy fields - **Missing fields**: Check that all required fields are included in the mapping - **Format errors**: Verify date formats, numbers, and text are properly formatted #### Field naming best practices for integration mapping When creating forms and fields in Tallyfy that will connect through Zapier, follow these naming conventions to prevent mapping confusion: - **Be specific with field names**: Instead of "Notes", use "Customer Requirements Notes" or "Technical Specifications Notes" - **Avoid duplicate field names**: If you have multiple similar fields, differentiate them clearly (e.g., "Billing Address" vs "Shipping Address" instead of "Address" twice) - **Use descriptive prefixes**: Add context like "Client_Name" vs "Manager_Name" instead of multiple "Name" fields - **Keep names consistent**: If a field appears in multiple forms, use the exact same name for easier mapping - **Avoid special characters**: Stick to letters, numbers, and underscores to prevent parsing issues Poor naming example that causes mapping confusion: - Additional Notes (which notes?) - Comments (whose comments?) - Date (what date?) Better naming for clear integration mapping: - Offering_Additional_Notes - Customer_Service_Comments - Contract_Start_Date ### Advanced troubleshooting For more complex integration issues: #### Testing your Zap 1. Use Zapier's testing feature to debug each step individually 2. Check the task/process history in Tallyfy to verify expected behavior 3. Review the Zap history in Zapier to see detailed execution logs #### Common error messages | Error Message | Possible Cause | Solution | |---------------|----------------|----------| | "Authentication failed" | Invalid credentials | Reconnect your Tallyfy account | | "Invalid client" | Incorrect API endpoint or missing grant_type | Use endpoint: go.tallyfy.com/api/token?client_id=[CLIENT_ID]&client_secret=[CLIENT_SECRET]&grant_type=developer | | "Template not found" | Incorrect template ID | Verify the template ID exists | | "User not found" | Incorrect assignee email | Check the email address is valid | | "Access denied" | Insufficient permissions | Use an account with proper permissions | | "Invalid field value" | Data formatting issue | Check field format requirements | #### Logging and debugging - Enable detailed logging in Zapier to capture more information - Use the "Debug" step in Zapier to inspect data at each stage - Monitor webhook delivery in Tallyfy's settings ### Best practices for Tallyfy-Zapier integration To minimize integration issues: - **Keep authentication fresh**: Reconnect your Tallyfy account periodically - **Document your Zaps**: Keep notes on what each Zap does and how it's configured - **Test thoroughly**: Test each Zap with various scenarios before relying on it - **Monitor regularly**: Set up notifications for failed Zaps - **Update carefully**: Test Zaps after making changes to Tallyfy templates - **Use descriptive names**: Name your Zaps clearly to make troubleshooting easier ### Getting additional help If you've tried these troubleshooting steps and still experience issues: 1. Check the [Zapier Help Center](https://zapier.com/help) 2. Review Tallyfy's [API documentation](https://tallyfy.com/products/pro/integrations/open-api/) 3. Contact [Tallyfy Support](https://tallyfy.com/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/) with details about your issue The more information you can provide about your issue, including screenshots, error messages, and the steps you've already taken, the faster our support team can help you resolve it. ### Power automate - **[Advanced conditions and expressions in Power Automate](https://tallyfy.com/products/pro/integrations/middleware/power-automate/advanced-conditions-and-expressions/)**: Power Automate's advanced conditional techniques including expressions grouped logic and Switch controls enable sophisticated decision-making in Tallyfy workflows by handling complex data scenarios multiple conditions and edge cases that basic if-then logic cannot accommodate. Basic conditional logic (if-this-then-that) works great for simple Tallyfy [processes](/products/pro/tracking-and-tasks/processes/) in Power Automate. But real workflows are messy. They need smarter decision-making - the kind that handles multiple conditions, complex calculations, and edge cases. Let's dive into advanced techniques you can use with your Tallyfy data: expressions, grouped conditions, and the Switch control that'll make your integrations actually handle what your business throws at them. ## Revisiting conditional logic As covered in our article on [using conditional logic in Power Automate](/products/pro/integrations/middleware/power-automate/using-conditional-logic-in-power-automate/), the **Condition** control is your go-to tool for decision-making in flows that interact with Tallyfy. It checks if something is true or false and sends the flow down different paths. Simple enough. But here's where it gets interesting - we can supercharge these conditions to handle complex Tallyfy data scenarios. ## Working with expressions in conditions Power Automate expressions are formulas that let you manipulate data from Tallyfy, perform calculations, and access specific properties of your dynamic content. Think of them as your Swiss Army knife for data manipulation. When you combine expressions with conditions, you can build logic that handles the quirks and edge cases in your actual business processes. To use an expression: 1. Click inside the value box when configuring a condition (or any field that accepts expressions). 2. The dynamic content pane will appear. Switch to the **Expression** tab. 3. Type or select functions to build your expression. Here are the expression functions you'll use most with Tallyfy data: * **String functions:** * `concat('string1', 'string2')`: Joins strings. * `substring('text', startIndex, length)`: Extracts part of a string. * `toLower('TEXT')` / `toUpper('text')`: Converts case (useful for case-insensitive comparisons of Tallyfy [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) values). * `equals('string1', 'string2')`: Compares two strings (often used within an `if` expression for complex logic). * `contains('text', 'searchText')`: Checks if text contains specific searchText. * `startsWith('text', 'searchText')` / `endsWith('text', 'searchText')`. * **Date/Time functions:** * `utcNow()`: Gets the current date and time in UTC. * `addDays(timestamp, days, 'format')`: Adds days to a date (e.g., calculating a new due date based on a Tallyfy [task's](/products/pro/tracking-and-tasks/tasks/) start date). * `formatDateTime(timestamp, 'formatString')`: Formats a date/time string (e.g., `'yyyy-MM-dd'`). * **Conversion functions:** * `int('stringValue')`: Converts a string (perhaps from a Tallyfy text [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/)) to an integer. * `string(value)`: Converts a value to a string. * `float('stringValue')`: Converts a string to a floating-point number. * **Logical functions (often used inside an `if` expression or directly in advanced mode):** * `if(condition, valueIfTrue, valueIfFalse)` * `and(condition1, condition2)` * `or(condition1, condition2)` * `not(condition)` * `empty(value)`: Checks if a value (string, array, object) is empty. * `equals(value1, value2)`: Checks for equality. **Tallyfy example:** Let's say you have a Tallyfy [task](/products/pro/tracking-and-tasks/tasks/) with a due date stored as a text [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) called `TaskDueDateText`. Want to check if it's overdue? Here's how: * **Value 1 (Expression):** `formatDateTime(outputs('Get_task_details')?['body/forms/TaskDueDateText/value'], 'yyyy-MM-dd')` * This assumes your Tallyfy due date text follows a consistent format. If formats vary (and they often do), you'll need more sophisticated parsing. * **Operator:** `is less than` * **Value 2 (Expression):** `formatDateTime(utcNow(), 'yyyy-MM-dd')` ## Grouping conditions (AND/OR logic) You can add multiple rows to a Condition control (as covered in the [basic conditions article](/products/pro/integrations/middleware/power-automate/using-conditional-logic-in-power-automate/)). But what if you need even more complex logic? That's where grouping comes in. 1. **Add multiple rows:** Click **+ Add** -> **Add row** within your condition. 2. **Select group:** Check the boxes next to the condition rows you want to group. 3. **Make group:** Click the ellipsis (...) on one of the selected rows and choose **Make group**. You can set an AND or OR operator for conditions *within* that group. Then set another AND or OR operator for how that group relates to other conditions or groups at the same level. It's like building logical parentheses around your conditions - perfect for those "if this AND that, OR if something else entirely" scenarios you encounter with real Tallyfy [processes](/products/pro/tracking-and-tasks/processes/). **Tallyfy example:** Escalate a Tallyfy [process](/products/pro/tracking-and-tasks/processes/) IF: (Tallyfy [process](/products/pro/tracking-and-tasks/processes/) Name CONTAINS "Urgent" AND Priority [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) IS "High") OR (Days Overdue (calculated via expression) IS GREATER THAN 3) ## Using the Switch control for multiple outcomes Ever created a tangled mess of nested if-this-then-that conditions? You know - checking one Tallyfy [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) value against 5, 10, or even 20 different possibilities? The **Switch** control saves you from that nightmare. It's cleaner, easier to read, and actually maintainable. * **Structure:** 1. Add a **Switch** control. 2. **On:** Specify the value the Switch will evaluate (e.g., dynamic content from a Tallyfy [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/)). 3. **Case:** For each possible value from your Tallyfy data, add a **Case** branch. In the **Equals** field of the Case, enter the specific value it should match. 4. Place the actions for that specific case within its branch. 5. **Default:** This branch executes if none of the preceding Case values match the "On" value from Tallyfy. ### How Switch control eliminates nested conditions This diagram shows how the Switch control provides clean, single-evaluation branching instead of complex nested if-then conditions. [Diagram removed for brevity] **What to notice:** - **Single evaluation point** - The Switch evaluates the Request Type field once, not repeatedly like nested conditions would - **No nesting required** - Each case branches directly from the central evaluation, keeping your flow clean and readable - **Default fallback** - Unknown or unexpected values automatically route to a default action, preventing flows from breaking **Tallyfy example:** Say your Tallyfy [task](/products/pro/tracking-and-tasks/tasks/) has a [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) called "Request Type" with three possible values: "Information," "Access," "Hardware." * SWITCH ON: `outputs('Get_task_details')?['body/forms/RequestType/value']` (pulls directly from Tallyfy) * CASE `Information`: * Action: Send an email with links to relevant knowledge base articles. * CASE `Access`: * Action: Create an approval request for system access, perhaps using [Power Automate approvals integrated with Teams](/products/pro/integrations/middleware/power-automate/integrating-power-automate-approvals-with-microsoft-teams/). * CASE `Hardware`: * Action: Launch a Tallyfy "Hardware Procurement" [procedure template](/products/pro/documenting/templates/). * DEFAULT: * Action: Notify IT support about an unclassified request from Tallyfy. ## Advanced conditional patterns * **Checking for null or empty values:** Here's a pro tip - always check if optional Tallyfy [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) are empty before using them. Nothing crashes a flow faster than trying to process a value that doesn't exist. Use the `empty()` expression: * Condition: `empty(outputs('Get_task_details')?['body/forms/OptionalComment/value'])` * Operator: `is equal to` * Value: `true` (expression) * **Error handling (Quick note):** You can use "Configure run after" settings on actions within your conditional branches to handle failures gracefully. If a step fails, you can define what happens next - retry, skip, or take an alternative path. This makes your Tallyfy automations resilient to real-world hiccups. More details in [managing and monitoring Power Automate flows](/products/pro/integrations/middleware/power-automate/managing-and-monitoring-power-automate-flows/). ## Best practices for advanced conditions with Tallyfy * **Readability:** Keep expressions readable. When logic gets complex, use a "Compose" action (see [working with data operations and variables](/products/pro/integrations/middleware/power-automate/working-with-data-operations-and-variables/)) to build parts of an expression and test its output. Then use that Compose output in your condition. Since Power Automate doesn't let you comment expressions directly, document complex flows externally. * **Modularity:** Drowning in nested conditions? Break the flow into smaller, callable child flows. Yes, it adds some management overhead, but it beats staring at 15 levels of indentation. * **Data type awareness:** Tallyfy [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) often store everything as text. Before comparing numbers or dates, convert them properly using `int()`, `float()`, or `formatDateTime()`. Trust me - comparing "10" to 2 as strings will give you unexpected results. * **Thorough testing:** Test every single path through your conditions and switches. Feed them different Tallyfy data - valid inputs, edge cases, empty values, the works. Better to find issues in testing than in production. - **[Automating Microsoft Entra ID with Power Automate](https://tallyfy.com/products/pro/integrations/middleware/power-automate/automating-azure-ad-with-power-automate/)**: Power Automate enables automated management of Tallyfy member access through Microsoft Entra ID by handling user provisioning and deprovisioning based on security group membership and generating compliance reports for access reviews. Microsoft Entra ID (formerly Azure Active Directory) is Microsoft's cloud-based identity service. If you're using Entra ID, Power Automate becomes an incredibly handy tool for automating those repetitive identity admin tasks. This really shines when you're managing Tallyfy [members](/products/pro/documenting/members/) and their access - especially if you've set up Entra ID for Single Sign-On ([SSO](/products/pro/integrations/authentication/)) with Tallyfy. ## Introduction to Entra ID automation for Tallyfy Want to save hours on user management? Automating Entra ID tasks with Power Automate speeds up everything Tallyfy-related: onboarding new users who need access, removing people when they leave, managing which groups get which Tallyfy roles, and pulling those compliance reports your auditors keep asking for. **Relevance to Tallyfy:** * **Managing Tallyfy [members](/products/pro/documenting/members/):** When your Tallyfy [member](/products/pro/documenting/members/) list syncs with Entra ID groups, Power Automate handles the heavy lifting - adding and removing users automatically. No more manual updates! * **Automating Tallyfy access via [SSO](/products/pro/integrations/authentication/):** Link Tallyfy [SSO](/products/pro/integrations/authentication/) to specific Entra ID security groups, then let Power Automate manage who's in those groups. It's that simple. * **Reporting for Tallyfy compliance:** Need to know who has Tallyfy access for your quarterly review? Generate reports on Entra ID group membership in seconds instead of hours. ## Key Entra ID actions in Power Automate for Tallyfy integration Here's what Power Automate gives you for working with Entra ID and Tallyfy: * **Entra ID Connector:** Your main tool for user and group operations that affect Tallyfy access. For the basics on connectors, check out [understanding Power Automate basics](/products/pro/integrations/middleware/power-automate/understanding-power-automate-basics/). * `Get user profile (V2)` and `Get manager (V2)`: Pull user details to make smart Tallyfy [task](/products/pro/tracking-and-tasks/tasks/) assignments. * `Create user`, `Update user`, `Delete user`: Automate the entire user lifecycle - when someone joins, changes roles, or leaves. * `Add user to group`, `Remove user from group`: Control who gets into those Entra ID groups that grant Tallyfy access. Works like a charm. * `List group members`, `List users`: Perfect for those "who has access to what" reports. * **Office 365 Groups Connector:** Handy if you're using Microsoft 365 Groups to organize teams that need Tallyfy access. * **HTTP with Microsoft Graph API (Advanced):** Need something the standard connectors can't do? Like pulling custom user attributes for Tallyfy role assignments? The HTTP action with Graph API has you covered. More details in [connecting Power Automate to external data](/products/pro/integrations/middleware/power-automate/connecting-power-automate-to-external-data/). ## Example: new Tallyfy member added to an Entra ID group **Scenario:** You want new Tallyfy [members](/products/pro/documenting/members/) from Sales automatically added to your "Tallyfy Users" Entra ID security group. No manual work required. *This example assumes you have a way to trigger the flow when someone new joins Tallyfy. Could be a Tallyfy [webhook](/products/pro/integrations/webhooks/) (if available for new member events), an HR system trigger, or - for this demo - a simple [manual trigger](/products/pro/integrations/middleware/power-automate/triggering-flows-manually-button-flows/).* ## Example: reporting on Entra ID users for Tallyfy access review **Scenario:** Every month, you need a CSV report of everyone in your "Tallyfy General Access" Entra ID group. Let's automate it and email it straight to whoever needs it. ## Using the HTTP connector for advanced Entra ID tasks affecting Tallyfy (brief overview) Hit a wall with the standard Entra ID connector? Maybe you need to pull specific user properties for Tallyfy role assignments. The HTTP action with Microsoft Graph API is your answer. We dive deeper into this in [connecting Power Automate to external data](/products/pro/integrations/middleware/power-automate/connecting-power-automate-to-external-data/). Here's what you'll need to tackle: 1. **App Registration in Entra ID:** Set up an app registration with the right API permissions for Tallyfy user data. 2. **Authentication Details:** Keep those credentials secure in your HTTP action. 3. **HTTP Action Configuration:** Configure the method, URI, headers, and body for your Graph API calls. 4. **Parse JSON Action:** Turn that JSON response into something your flow can actually use. Yes, it's more complex - you'll need to understand Entra ID app registrations and Graph API. But the flexibility? Worth it. ## Tips for Tallyfy and Entra ID automation * **Permissions:** Give your API permissions and service accounts only what they absolutely need. Nothing more. * **Use group IDs:** Display names change, Object IDs don't. Always use the Group Object ID in your flows. * **Testing:** If regular users will run these flows, test with their permissions - not your admin account. * **User lifecycle:** Hook into Entra ID lifecycle events to automatically provision and deprovision Tallyfy [members](/products/pro/documenting/members/). Especially powerful with [SSO](/products/pro/integrations/authentication/). - **[Building approval workflows with Power Automate](https://tallyfy.com/products/pro/integrations/middleware/power-automate/building-approval-workflows-with-power-automate/)**: This guide explains how to use Power Automate's approval features to handle formal sign-offs that extend beyond Tallyfy's built-in task assignments by creating automated workflows that request approvals and update Tallyfy processes based on the outcomes. Many business [processes](/products/pro/tracking-and-tasks/processes/) require formal sign-off. While Tallyfy handles [task](/products/pro/tracking-and-tasks/tasks/) assignments and completions beautifully, you'll sometimes need Power Automate's approvals feature for more formal sign-offs. Think audit trails. Complex routing. External stakeholders who aren't in Tallyfy every day. ## Introduction to Power Automate approvals for Tallyfy Power Automate approvals let you create automated workflows that request and track formal sign-off. Connect a flow to Tallyfy, trigger an approval action - boom, request goes to your designated approvers. Here's where it gets interesting. You can use Power Automate approvals for those formal sign-off steps that wrap around your Tallyfy [processes](/products/pro/tracking-and-tasks/processes/). Picture this: your internal Tallyfy process produces a document that needs client approval. Power Automate handles that external approval loop, then updates your Tallyfy process based on what the client decides. :::note[Dataverse Backend] Power Automate approvals use Microsoft Dataverse in the background to store approval history. You typically don't need to interact directly with Dataverse for standard Tallyfy-related approval scenarios. ::: ## Types of approval actions in Power Automate for Tallyfy scenarios When you're building approval flows for Tallyfy items, you'll mostly work with actions from the "Approvals" [connector](/products/pro/integrations/middleware/power-automate/understanding-power-automate-basics/): * **Start and wait for an approval:** Your go-to choice. Kicks off an approval for a Tallyfy-related item and waits patiently for a response. * *Common Types within this action:* * **Approve/Reject - First to respond:** If sent to multiple people for a Tallyfy item, the first response determines the outcome. * **Approve/Reject - Everyone must approve:** Everyone has to weigh in. One rejection? That's a no-go for your Tallyfy item. * **Custom Responses - Wait for one response / Wait for all responses:** Define custom action buttons beyond Approve/Reject for Tallyfy item approvals. * **Create an approval** and **Wait for an approval (separate actions):** For advanced scenarios like parallel approvals related to a Tallyfy [process](/products/pro/tracking-and-tasks/processes/). ## Building a simple approval flow for a Tallyfy scenario Let's build something real. We'll create a flow where completing a Tallyfy [task](/products/pro/tracking-and-tasks/tasks/) triggers manager approval - but only when a financial threshold in a [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) is crossed. **The scenario:** Your team member wraps up a "Submit Budget Proposal" [task](/products/pro/tracking-and-tasks/tasks/) in Tallyfy. The task has a [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) for "Proposed Amount." Anything over $5,000? That needs manager approval through Power Automate. Then we update the Tallyfy task with whatever happens. ### Approval workflow visualization This diagram shows how the budget approval flow routes between Tallyfy and Power Automate based on the amount threshold. [Diagram removed for brevity] **Diagram description:** This flow diagram illustrates a budget approval workflow that integrates Tallyfy with Power Automate, showing how a completed task triggers conditional approval based on a $5,000 threshold. The workflow branches at decision points to either bypass approval for smaller amounts or route through manager approval for larger amounts, with different colored paths indicating success (green) and rejection (yellow/dashed) scenarios. **What to notice:** - The $5,000 threshold creates two distinct paths - amounts below bypass approval entirely while higher amounts trigger the full approval flow - Manager approval happens outside Tallyfy in Power Automate, but the result always updates back to the original Tallyfy task for complete visibility - The rejection path includes an optional email notification, showing how you can add custom actions based on approval outcomes ## Responding to approvals for Tallyfy items Approvers have three ways to respond: * **Email:** Click the buttons right in the email for the Tallyfy item. * **Power Automate Portal:** Find it under **Action items** > **Approvals**. * **Microsoft Teams:** Got the [Teams integration](/products/pro/integrations/middleware/power-automate/integrating-power-automate-approvals-with-microsoft-teams/)? Respond without leaving Teams. ## Sequential and parallel approvals for Tallyfy (introduction) Need something more complex for your Tallyfy [processes](/products/pro/tracking-and-tasks/processes/)? You've got options: * **Sequential approvals:** The request travels from one approver to the next - like a relay race for your Tallyfy item. * **Parallel approvals:** Fire off requests to multiple people at once. Everyone reviews your Tallyfy item simultaneously. Mix and match these patterns to build sophisticated approval routes that match how your organization actually works. ## Tips for Tallyfy approval workflows using Power Automate * **Clear criteria:** Know exactly what Tallyfy event kicks off an approval. Know who's approving. * **Context matters:** Pull data from Tallyfy [tasks](/products/pro/tracking-and-tasks/tasks/) or [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) into your approval request. Approvers need the full picture. * **Close the loop:** Whatever happens in Power Automate, push it back to the original Tallyfy [task](/products/pro/tracking-and-tasks/tasks/) or [process](/products/pro/tracking-and-tasks/processes/). Keep everything visible in Tallyfy. * **Keep it simple:** Basic approvals? Stick with Tallyfy's built-in task assignments. Save Power Automate for the complex stuff - multi-level approvals, external stakeholders, conditional routing. - **[Creating your first flow in Power Automate](https://tallyfy.com/products/pro/integrations/middleware/power-automate/creating-your-first-flow-in-power-automate/)**: This guide demonstrates how to create an automated Power Automate flow that monitors your Outlook inbox for specific emails and instantly creates corresponding tasks in Tallyfy using the connector with detailed configuration steps and testing procedures. ## Create your first Power Automate flow You can connect Power Automate to Tallyfy in about 10 minutes - and this guide shows you exactly how. We'll build a real flow that automatically creates Tallyfy tasks whenever you receive specific emails. Why start with email-to-task automation? It's practical, you'll use it immediately, and it teaches the fundamentals you need for more complex integrations. ## Prerequisites Before you start, ensure you have: * **Microsoft Power Automate access:** You need a license that lets you create flows. Most Microsoft 365 subscriptions include this. * **A Tallyfy Pro account:** You'll use this with the Tallyfy [connector](/products/pro/integrations/middleware/power-automate/how-can-i-integrate-tallyfy-with-microsoft-power-automate/) to work with [processes](/products/pro/tracking-and-tasks/processes/) and [procedure templates](/products/pro/documenting/templates/). * **A clear goal for Tallyfy integration:** Know what you're trying to automate - it makes setup much easier. ### What scenario will this Power Automate flow accomplish? Here's what we're building: a flow that watches your Outlook inbox for emails with "New Sales Lead Received" in the subject line. When one arrives, it instantly creates a task in your Tallyfy "Lead Follow-Up" template. No more copying and pasting from emails. No forgotten leads. The flow catches every qualified email and turns it into an actionable [task](/products/pro/tracking-and-tasks/tasks/) in your [procedure template](/products/pro/documenting/templates/) - complete with the email subject and body content. It just works. ## How the email-to-task automation flow works This diagram shows the complete automation flow from email arrival to task creation in Tallyfy. [Diagram removed for brevity] ### What to notice - **Step 4** shows the subject filter check - only emails with "New Sales Lead Received" trigger the flow, preventing accidental task creation from every email - **Steps 6-7** demonstrate the API authentication using your Organization ID, API Key, and API Secret to securely connect Power Automate to Tallyfy - **Step 10** confirms task creation in Tallyfy - the email content becomes a trackable task with automatic deadline setting (+1 day) ## Steps to create your first automated flow for Tallyfy ## Understanding the flow designer UI for Tallyfy integration The Power Automate flow designer is where you'll spend most of your time. Here's what matters: * **Triggers and Actions:** These are your building blocks - triggers start the flow, actions do the work. * **Dynamic Content Pane:** This shows data from previous steps (like the email subject) that you can drop into Tallyfy fields. * **Expression Editor:** For date calculations and text manipulation. (See [advanced conditions and expressions](/products/pro/integrations/middleware/power-automate/advanced-conditions-and-expressions/)). * **Save, Test, Flow Checker:** Your control panel - save often, test everything. ## Testing your Tallyfy-integrated flow Let's make sure everything works before you rely on it. ## Tips for creating flows with Tallyfy * This email-to-task pattern captures every important request in your Tallyfy [processes](/products/pro/tracking-and-tasks/processes/) - nothing falls through the cracks. * The Tallyfy [connector](/products/pro/integrations/middleware/power-automate/how-can-i-integrate-tallyfy-with-microsoft-power-automate/) has other actions too: **Launch process** (better for starting fresh processes), **Update task**, and **Get task details**. * Think about other emails that trigger work in your organization. Support tickets? Purchase orders? They can all flow into Tallyfy automatically. * Need something the connector doesn't do? Tallyfy's [Open API](/products/pro/integrations/open-api/) handles the advanced stuff. - **[Connecting Power Automate to external data sources](https://tallyfy.com/products/pro/integrations/middleware/power-automate/connecting-power-automate-to-external-data/)**: Power Automate enables seamless integration between Tallyfy processes and external data sources by connecting databases and Microsoft Forms while supporting data logging task automation and process initiation through user-friendly interfaces. Want to connect Tallyfy to your databases and forms? Power Automate makes it happen. You can push data into Tallyfy, pull it out for reports, or trigger workflows when specific events occur in external systems. This article covers two practical scenarios: connecting SQL databases to Tallyfy and using Microsoft Forms responses to kick off Tallyfy [processes](/products/pro/tracking-and-tasks/processes/). We'll walk through real examples you can implement today. Here's the thing - Tallyfy already offers direct integration options through its [Open API](/products/pro/integrations/open-api/), [webhooks](/products/pro/integrations/webhooks/), and the Tallyfy Power Automate [connector](/products/pro/integrations/middleware/power-automate/how-can-i-integrate-tallyfy-with-microsoft-power-automate/). You've got choices. ## Working with databases (e.g., SQL Server) to support Tallyfy Your databases hold valuable business data. Let's get that data working with Tallyfy - whether you're logging process outcomes for reporting or triggering workflows based on database changes. * **Why connect Tallyfy to a database via Power Automate?** * **Log Tallyfy data for reporting:** Automatically log details of completed Tallyfy [processes](/products/pro/tracking-and-tasks/processes/) or specific [task](/products/pro/tracking-and-tasks/tasks/) outcomes into a SQL database for advanced reporting. This can supplement [Tallyfy Analytics](/products/pro/integrations/analytics/). * **Archive Tallyfy details:** Systematically archive Tallyfy [task](/products/pro/tracking-and-tasks/tasks/) information, including [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) data, into a data warehouse. * **Trigger Tallyfy from database events:** When a new record is added to a database (e.g., a new customer in a CRM's database), a Power Automate flow can trigger and launch a Tallyfy "New Customer Onboarding" [procedure template](/products/pro/documenting/templates/). * **SQL Server connector in Power Automate:** The SQL Server [connector](/products/pro/integrations/middleware/power-automate/understanding-power-automate-basics/) gives you these options: * **Triggers:** `When an item is created (V2)`, `When an item is modified (V2)`. * **Actions:** `Get rows (V2)`, `Insert row (V2)`, `Update row (V2)`, `Delete row (V2)`, `Execute SQL query (V2)`. * **Setting up a connection:** You'll need your server name, database name, and authentication details. Takes about 2 minutes. * **Example: logging Tallyfy task completion to SQL** ## Processing Microsoft Forms responses to initiate Tallyfy processes Need a simple way for users to kick off Tallyfy workflows? Microsoft Forms provides an easy front-end, and Power Automate connects the dots. Users fill out a form, Tallyfy launches the right process. Done. * **Why use Microsoft Forms with Tallyfy via Power Automate?** * **User-friendly Tallyfy process initiation:** Use a simple Microsoft Form for users to submit requests that kick off a Tallyfy [process](/products/pro/tracking-and-tasks/processes/) (e.g., an IT support request form that launches a Tallyfy support [procedure template](/products/pro/documenting/templates/)). * **Detailed data collection for Tallyfy:** Collect information through a Form and use Power Automate to populate multiple [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) in a Tallyfy [task](/products/pro/tracking-and-tasks/tasks/) or launch form. * **Feedback loop for Tallyfy:** Gather feedback about a completed Tallyfy [process](/products/pro/tracking-and-tasks/processes/) using a Form, and use Power Automate to link this feedback back to the specific Tallyfy process instance. * **Microsoft Forms connector:** (check out [understanding Power Automate basics](/products/pro/integrations/middleware/power-automate/understanding-power-automate-basics/) for connector details) * **Trigger:** `When a new response is submitted`. * **Action:** `Get response details`. * **Example: launch Tallyfy Process from Form submission** ## Gathering user input in manual flows for Tallyfy (recap) Remember those [button flows](/products/pro/integrations/middleware/power-automate/triggering-flows-manually-button-flows/)? They can grab user input on the fly. Why does this matter here? Because user input is external data too. When someone clicks your button flow and types in "Client Name" and "Issue Description," Power Automate can instantly create a high-priority [task](/products/pro/tracking-and-tasks/tasks/) in your Tallyfy support [process](/products/pro/tracking-and-tasks/processes/). It's that direct. ## Tips for data integration with Tallyfy * **Data type compatibility:** Watch your data types - Tallyfy expects specific formats. Use Power Automate [expressions](/products/pro/integrations/middleware/power-automate/advanced-conditions-and-expressions/) like `int()` or `string()` to convert when needed. * **Unique Tallyfy identifiers:** Always log Process ID or Task ID when sending Tallyfy data to external systems. You'll thank yourself later when tracking down specific records. * **Inspect with "Compose":** Can't figure out what data you're getting? Drop in a "Compose" action (see [working with data operations and variables](/products/pro/integrations/middleware/power-automate/working-with-data-operations-and-variables/)) to inspect payloads during testing. * **Tallyfy [Open API](/products/pro/integrations/open-api/) as an alternative:** Hit a wall with the connector? Power Automate's HTTP action plus Tallyfy's [Open API](/products/pro/integrations/open-api/) can handle complex scenarios the connector can't. - **[Connect Tallyfy to Power Automate](https://tallyfy.com/products/pro/integrations/middleware/power-automate/how-can-i-integrate-tallyfy-with-microsoft-power-automate/)**: This guide explains how to connect Tallyfy to Microsoft Power Automate in about five minutes by creating a new flow and configuring the Tallyfy connector with your organization ID and API credentials to enable automated workflows between Tallyfy and Microsoft ecosystem applications. ## Setting up the Tallyfy connection You can connect Tallyfy to Microsoft Power Automate (formerly Flow) in about 5 minutes. This [integration](/products/pro/integrations/) service links Tallyfy with the Microsoft ecosystem and hundreds of other business applications - letting you automate workflows between Tallyfy and pretty much everything else you use. ### Benefits of integrating Tallyfy with Power Automate - **Connect Tallyfy to the Microsoft ecosystem**: Link Tallyfy with Office 365, Dynamics, and other Microsoft products. - **Low-code Tallyfy [automations](/products/pro/documenting/templates/automations/)**: Use a visual workflow builder to create automations for Tallyfy. - **Bidirectional data flow with Tallyfy**: Send data to and retrieve information from your Tallyfy [processes](/products/pro/tracking-and-tasks/processes/). - **Conditional logic for Tallyfy workflows**: Build decision-based automation flows that interact with Tallyfy data. - **Use existing [security](/products/pro/compliance/)**: Secure authentication mechanisms protect the connection to Tallyfy. ### Connection setup process for Tallyfy Here's exactly how to establish the connection between Tallyfy and Power Automate: Once you've done this, Power Automate stores your Tallyfy connection securely. You won't need to re-enter these credentials - just use the same connection in all your future flows. ### Implementation demonstration Watch how the connection process works in this walkthrough video: ### Additional Tallyfy resources Want to go deeper? Check out our documentation on the [Tallyfy Open API](/products/pro/integrations/open-api/) and [webhooks](/products/pro/integrations/webhooks/) for advanced integration scenarios. While Microsoft provides [general documentation on its connectors](https://docs.microsoft.com/en-us/connectors/tallyfy/), Tallyfy's own resources give you the most specific guidance for getting the most out of Tallyfy features. - **[Integrating Power Automate approvals with Microsoft Teams](https://tallyfy.com/products/pro/integrations/middleware/power-automate/integrating-power-automate-approvals-with-microsoft-teams/)**: Integrating Power Automate approvals with Microsoft Teams centralizes Tallyfy approval notifications within Teams to reduce app switching and accelerate decision-making through interactive Adaptive Cards that enable instant approval responses. Microsoft Teams has become the collaboration hub for countless organizations. Integrating Power Automate approvals directly into Teams streamlines your Tallyfy-related approval [processes](/products/pro/tracking-and-tasks/processes/) and cuts down on the constant app-switching that slows everyone down. Decision-making speeds up too. Tallyfy already has excellent built-in approval features, but if your team lives in Teams all day, this integration makes sense. ## Why integrate Power Automate approvals with Teams for Tallyfy? Here's what you gain when you bring Power Automate approvals into Teams for Tallyfy-related decisions: * **Centralized notifications in Teams:** Approvers get notified and respond to requests without leaving Teams. Everything stays in one place. * **Reduced context switching:** If you're already working in Teams, you don't have to constantly check email for Tallyfy-related approvals through Power Automate. * **Faster responses:** When approvals pop up right in Teams, people respond in minutes instead of hours. Your Tallyfy [processes](/products/pro/tracking-and-tasks/processes/) and [tasks](/products/pro/tracking-and-tasks/tasks/) keep moving. * **Enhanced visibility:** Want the whole team to see approval requests for Tallyfy items? Post them to a Teams channel. ## Prerequisites Before you begin, ensure you have: * **Power Automate approvals set up:** You should be familiar with creating approval workflows in Power Automate as detailed in our article on [building approval workflows with Power Automate](/products/pro/integrations/middleware/power-automate/building-approval-workflows-with-power-automate/). * **Microsoft Teams with Power Automate app:** Users involved in the approval process for Tallyfy items should have Microsoft Teams and the Power Automate app (sometimes referred to as the "Flow bot", see [understanding Power Automate basics](/products/pro/integrations/middleware/power-automate/understanding-power-automate-basics/)) installed. ## Posting approval requests to Teams for Tallyfy items You'll use Microsoft Teams connector actions in Power Automate to send approval requests straight to users or channels. **Adaptive Cards** are your best bet here. * **Adaptive Cards:** Think of these as interactive widgets that appear in Teams. For Tallyfy approvals, an Adaptive Card displays the important details and gives you "Approve" and "Reject" buttons right there - no extra clicks needed. * **Teams connector actions:** (Details in [understanding Power Automate basics](/products/pro/integrations/middleware/power-automate/understanding-power-automate-basics/)) * `Post adaptive card in a chat or channel` * `Post a choice of options as the Flow bot to a user` (works for simpler scenarios) **Flow modification example (building on a Tallyfy budget approval scenario):** Let's walk through a real example. You've got a Power Automate flow using "Start and wait for an approval" for a Tallyfy-triggered budget request (covered in the [building approval workflows](/products/pro/integrations/middleware/power-automate/building-approval-workflows-with-power-automate/) article). Want to add Teams integration? Here's how: That's it. When your flow runs, the approver gets an Adaptive Card right in Teams. They can approve or reject the Tallyfy item instantly - no app switching required. ## Approval flow visualization This diagram shows how an approval request flows through Tallyfy, Power Automate, and Microsoft Teams. [Diagram removed for brevity] **What to notice:** - The flow pauses at step 5 while waiting for the approver's response - this is the asynchronous "wait" that makes the integration powerful - The Adaptive Card posted to Teams (step 3) contains all the approval details and action buttons, eliminating the need to switch apps - The entire round-trip from Tallyfy trigger to final update happens without the approver leaving Microsoft Teams ## Handling responses from Teams approvals for Tallyfy * **Using "Start and wait for an approval":** This is the easy path. You use the `Teams Adaptive Card` output from a "Start and wait for an approval" action linked to your Tallyfy item, and Power Automate does the heavy lifting. The flow pauses and waits. User clicks a button in Teams? The response comes back automatically. Your flow continues, and you can grab the `Outcome` and `Comments` to update the Tallyfy [task](/products/pro/tracking-and-tasks/tasks/) or [process](/products/pro/tracking-and-tasks/processes/). * **Custom Adaptive Cards with `Action.Submit`:** Built a custom Adaptive Card for your Tallyfy approval? Things get trickier. You'll need another flow or some clever logic to match the response back to the original Tallyfy item. Honestly? For most Tallyfy scenarios, stick with the standard "Start and wait for an approval" action and its `Teams Adaptive Card` output. It just works. ## Notifying users in Teams about Tallyfy events Approvals are just the beginning. The Microsoft Teams connector can handle all sorts of Tallyfy notifications: * **Tallyfy task overdue:** Set up a flow that triggers when a Tallyfy [task](/products/pro/tracking-and-tasks/tasks/) passes its deadline (you'll need a scheduled flow checking task statuses through Tallyfy's [API](/products/pro/integrations/open-api/) or a [webhook](/products/pro/integrations/webhooks/) if there's one for due dates). Post to a Teams channel and tag whoever dropped the ball. * **Tallyfy process completion:** Did someone just finish the "New Client Onboarding" [process](/products/pro/tracking-and-tasks/processes/)? Have the Tallyfy connector trigger a celebration message in your project channel. * **New Tallyfy task assignment:** High-priority task just landed? Send the assignee a Teams DM with all the Tallyfy task details and a direct link. They can't miss it. ## Best practices for Teams and Tallyfy integration * **Clarity in cards:** Your Adaptive Cards for Tallyfy approvals need to be crystal clear. Strip out the fluff - just the essentials. Always include links back to the Tallyfy [task](/products/pro/tracking-and-tasks/tasks/) or [process](/products/pro/tracking-and-tasks/processes/) for context. * **Flow bot adoption:** Make sure everyone who needs Tallyfy approvals or notifications in Teams actually has the Power Automate app installed. (Check this before you go live!) * **Thorough testing:** Run through the entire Tallyfy-to-Teams flow before unleashing it on your team. Trust me on this one. * **Targeted notifications:** Individual Tallyfy approvals? Send DMs. Team-wide updates about Tallyfy processes? Post to channels. Match the message to the audience. * **Complement, don't overwhelm:** Here's the thing - Tallyfy already has solid notifications. Only add Teams notifications where they genuinely speed things up. Nobody wants duplicate alerts for every single Tallyfy [process](/products/pro/tracking-and-tasks/processes/) update. - **[Introduction to RPA with Power Automate](https://tallyfy.com/products/pro/integrations/middleware/power-automate/introduction-to-rpa-with-power-automate/)**: Power Automate Desktop provides RPA capabilities to bridge Tallyfy with legacy desktop applications that lack APIs by automating UI interactions through software bots that click buttons type text and navigate menus just like humans would. Power Automate often connects modern cloud services with Tallyfy through APIs. But what about those ancient desktop applications still running in your organization? The ones without APIs? That's where Robotic Process Automation (RPA) comes in - and Power Automate Desktop is Microsoft's tool for building these UI-based automations. RPA helps you bridge Tallyfy with older systems, extending your Tallyfy [process](/products/pro/tracking-and-tasks/processes/) automation to systems that don't offer modern integration methods. ## What is Robotic Process Automation (RPA)? RPA uses software "robots" (bots) to automate repetitive tasks by mimicking how humans interact with digital systems. Instead of connecting programmatically via an [API](/products/pro/integrations/open-api/) (Tallyfy's preferred method), an RPA bot interacts with an application's user interface - it clicks buttons, types text into fields, and navigates menus. Just like you would. Here's the difference from API-based automation (like Tallyfy's [Open API](/products/pro/integrations/open-api/) or [webhooks](/products/pro/integrations/webhooks/)): RPA works at the presentation layer - the screen. It's an option when target systems are old, don't have accessible APIs, or when API development is too costly for the specific task you need to integrate with Tallyfy. RPA comes in two flavors: * **Attended RPA:** The bot works alongside a human, often initiated by them to automate part of their task. It runs on the user's workstation. * **Unattended RPA:** The bot runs independently in the background, typically on a dedicated machine. Perfect for batch-processing tasks that interact with systems connected to Tallyfy. ## Power Automate Desktop **Power Automate Desktop** is the application you'll use to design RPA flows (desktop flows). It provides a visual designer and actions to interact with desktop applications and UI elements. What you get: * **UI element recorder:** Records mouse clicks and keyboard inputs to generate initial flow steps. * **UI element selector:** Precisely identifies UI elements so the bot can reliably interact with them. * **Pre-built actions:** A library of actions for common desktop operations. * **Variable passing:** Receives input data from [cloud flows](/products/pro/integrations/middleware/power-automate/understanding-power-automate-basics/) (which might be triggered by Tallyfy) and passes output data back. ## When to consider RPA with Tallyfy Let's be honest - RPA is your last resort when API-based integration with Tallyfy isn't feasible. But it can work in these scenarios: * **Bridging Tallyfy with legacy systems:** Your Tallyfy [process](/products/pro/tracking-and-tasks/processes/) needs to interact with that ancient on-premises desktop application that has no [API](/products/pro/integrations/open-api/) (like a 15-year-old accounting system)? RPA can automate those interaction steps, triggered by or feeding data to Tallyfy. * **Automating data entry from Tallyfy to legacy apps:** Data collected in a Tallyfy [task's](/products/pro/tracking-and-tasks/tasks/) [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) can be automatically entered into a legacy desktop application. Think customer details from a completed Tallyfy onboarding task being created as a record in an old CRM. * **Extracting data from legacy apps for Tallyfy:** An RPA bot logs into a legacy system, scrapes data, and a Power Automate [cloud flow](/products/pro/integrations/middleware/power-automate/understanding-power-automate-basics/) uses that data to initiate or update a Tallyfy [process](/products/pro/tracking-and-tasks/processes/). Remember: if a system offers an API, use it. APIs through Power Automate's HTTP connector or custom connectors are far more stable than RPA. Tallyfy's [Open API](/products/pro/integrations/open-api/) and [webhooks](/products/pro/integrations/webhooks/) remain your best bet for direct integration with Tallyfy. ## Core concepts in Power Automate Desktop flows for Tallyfy integration When building desktop flows to interact with Tallyfy data (passed via a cloud flow): * **UI elements:** Specific components of an application's interface your bot interacts with. * **Recorder:** A feature to translate your actions into flow steps, often requiring refinement. * **Actions:** The Power Automate Desktop designer provides actions like "Launch application," "Click UI element in window," and "Populate text field in window." * **Input/Output variables:** Critical for connecting desktop flows with Power Automate [cloud flows](/products/pro/integrations/middleware/power-automate/understanding-power-automate-basics/). Input variables allow a cloud flow (triggered by Tallyfy) to pass data *into* the desktop flow. Output variables allow the desktop flow to pass results *back* to the calling cloud flow, which could then update Tallyfy. ## Example: updating a legacy desktop app from Tallyfy task data (conceptual) Building a full RPA flow takes work. Here's a conceptual outline for updating an old desktop CRM using data from a completed Tallyfy [task](/products/pro/tracking-and-tasks/tasks/). **The scenario:** A Tallyfy "Client Information Update" [task](/products/pro/tracking-and-tasks/tasks/) is completed. You've got client details (like a new phone number) captured in its [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/). These need to go into a legacy desktop CRM with no API. ## RPA integration flow This diagram shows how data flows from Tallyfy through Power Automate's cloud and desktop components to update legacy systems. [Diagram removed for brevity] **What to notice:** - **Cloud-desktop separation** - Steps 1-4 happen in the cloud, while steps 7-12 execute on your local machine or server - **Data handoff at step 5** - The gateway bridges cloud flows with desktop automation, passing Tallyfy form data as input variables - **UI automation sequence** - Steps 7-12 show the RPA bot mimicking human interactions with the legacy CRM interface **1. Cloud Flow (Power Automate):** **2. Desktop Flow (Designed in Power Automate Desktop):** ## Setting up Power Automate Desktop and gateways for Tallyfy integration * **Power Automate Desktop installation:** Install Power Automate Desktop on the machine where the RPA bot will run. * **On-premises data gateway:** For Power Automate [cloud flows](/products/pro/integrations/middleware/power-automate/understanding-power-automate-basics/) (like those triggered by Tallyfy) to initiate *unattended* desktop flows on an on-premises machine, an on-premises data gateway must be installed and configured. This acts as a bridge for secure communication. ## Considerations for RPA with Tallyfy * **Robustness and fragility:** UI automation is less stable than API integrations. One UI change in the legacy application can break your entire RPA flow. You'll need regular maintenance for RPA solutions connected to Tallyfy. * **Error handling:** You must implement thorough error handling in your desktop flow. Check out [managing and monitoring flows](/products/pro/integrations/middleware/power-automate/managing-and-monitoring-power-automate-flows/) for error concepts. * **Security:** Be extremely cautious with credentials in desktop flows (especially for unattended bots). * **Alternative exploration:** Before jumping to RPA, investigate whether the legacy system has any other integration methods - undocumented APIs, file import/export capabilities. These work more reliably for Tallyfy integrations. * **Tallyfy's strengths:** Tallyfy provides powerful [API](/products/pro/integrations/open-api/) and [Webhook](/products/pro/integrations/webhooks/) capabilities. Always use these first for integrating directly with Tallyfy or triggering external automations *from* Tallyfy. Don't use RPA to interact *with* Tallyfy itself. RPA with Power Automate Desktop extends Tallyfy's reach into environments with older applications lacking APIs. Just plan carefully. - **[Managing and monitoring power automate flows](https://tallyfy.com/products/pro/integrations/middleware/power-automate/managing-and-monitoring-power-automate-flows/)**: This guide covers managing Power Automate flows integrated with Tallyfy including sharing flows with co-owners for team collaboration and business continuity and exporting/importing flows for backups and environment migrations and monitoring run history to track automation success and troubleshooting common issues like authentication errors and API throttling while following best practices such as clear naming and regular reviews and documentation. Once you've built Power Automate flows - especially those integrated with your critical Tallyfy [processes](/products/pro/tracking-and-tasks/processes/) - you need to manage and monitor them properly. This guide walks you through managing these flows, including collaboration, backups, environment migrations, and troubleshooting common Tallyfy connection issues. ## Sharing and collaborating on flows Automating your Tallyfy [processes](/products/pro/tracking-and-tasks/processes/) is rarely a solo effort. You'll often need teammates to help build, test, and maintain flows. Power Automate's sharing features keep your Tallyfy automations running smoothly even when team members change. * **Why share flows?** * **Team collaboration:** Multiple people can work on the same flow, testing and improving it together. * **Business continuity:** What happens when someone leaves? Shared ownership means your automations don't break when the original creator moves on. * **Adding co-owners:** * You can add other users or Microsoft 365 groups as co-owners of a cloud flow. * Co-owners get full permissions - they can edit the flow, check its run history, and manage connections (like the [Tallyfy connector](/products/pro/integrations/middleware/power-automate/how-can-i-integrate-tallyfy-with-microsoft-power-automate/)) for that specific flow. They can even add or remove other owners. * To add a co-owner: Navigate to **My flows** in Power Automate, select the flow, and click **Share**. Type in the person's name or email. * **Connection sharing:** Here's something important - when you share a flow, its connections (to Tallyfy, Outlook, SharePoint) become available to co-owners *only for that flow*. They can't use these connections in their other flows. * **Run-only users (for manually triggered flows):** * For instant (button) flows that can be [triggered manually](/products/pro/integrations/middleware/power-automate/triggering-flows-manually-button-flows/), you can grant run-only permissions. * These users can trigger the flow - like starting a Tallyfy [process](/products/pro/tracking-and-tasks/processes/) with a button click - but they can't peek under the hood or change anything. * Perfect for giving teams standardized tools without letting them accidentally break the automation. * To set run-only permissions: Go to the flow's details page, find the **Run only users** section, and click **Edit**. * **Sharing desktop flows:** Desktop flows for [RPA](/products/pro/integrations/middleware/power-automate/introduction-to-rpa-with-power-automate/) work the same way. You can share them with run or co-owner permissions through the Power Automate web portal. ## Exporting and importing flows You'll need to export and import flows for several reasons - backing them up, moving between environments, or sharing your automation solutions with other teams using Tallyfy. * **Why export/import?** * **Backup and recovery:** Export your complex Tallyfy integrations regularly. Trust me, you'll thank yourself later. * **Environment migration:** Move flows from test to production without rebuilding everything from scratch. * **Sharing solutions:** Package a flow with all its dependencies to share with other teams in your organization. * **Exporting a flow:** 1. Go to **My flows** in Power Automate, find the flow you want to export. 2. Click the ellipsis (...) and select **Export** > **Package (.zip)**. 3. Give your package a **Name** and **Description**. 4. Under "Review Package Content," decide what happens on import for each resource - update existing items or create new ones. 5. Click **Export**. You'll get a .zip file. * **Importing a flow:** 1. Go to **My flows** and click **Import**. 2. **Upload** the .zip package file. 3. During import, configure each resource: * For the flow: Choose **Create as new** or **Update an existing flow**. * For connections (like your [Tallyfy connector](/products/pro/integrations/middleware/power-automate/how-can-i-integrate-tallyfy-with-microsoft-power-automate/) or SharePoint): Pick an existing connection or create a new one. 4. When everything shows green checkmarks, click **Import**. ## Monitoring flow run history Want to know if your Tallyfy automations are actually working? The run history tells you everything. Access it through the [Power Automate interface](/products/pro/integrations/middleware/power-automate/understanding-power-automate-basics/). * **Accessing run history:** * Click on a flow name in **My flows** to see its details page with run history. * Or click the ellipsis (...) next to any flow and select **Run history**. * **Understanding the run history:** Each run shows: * **Start time** * **Duration** * **Status:** `Succeeded`, `Failed`, `Cancelled`, or `Running`. * **Drilling into a Specific Run:** Click any run's start time to see exactly what happened step by step. * Expand each step to see **Inputs** and **Outputs**. * For Tallyfy integrations, this shows you the exact data received from Tallyfy triggers, what you sent to Tallyfy actions (like "Create task" through the [Tallyfy connector](/products/pro/integrations/middleware/power-automate/how-can-i-integrate-tallyfy-with-microsoft-power-automate/)), and Tallyfy's response. * **Resubmitting failed flows:** Service hiccup caused a failure? You can often resubmit the failed run with the same trigger data right from the history page. ## Basic troubleshooting Things not working? Here's how to troubleshoot your Tallyfy-integrated flows. (If you're new to this, check out [Power Automate basics](/products/pro/integrations/middleware/power-automate/understanding-power-automate-basics/) first.) * **Flow checker:** Before running anything, click the **Flow checker** (look for the stethoscope icon). It catches errors before they happen. * **Common error types & solutions:** * **Authentication errors:** See "Unauthorized" or HTTP 401/403 errors? Your credentials expired. * *Solution:* Edit the flow, find the failing connection (could be your [Tallyfy connector](/products/pro/integrations/middleware/power-automate/how-can-i-integrate-tallyfy-with-microsoft-power-automate/), Outlook, or SharePoint), and re-authenticate. * **Action configuration errors:** Missing required fields or wrong data types (like text where numbers should be). * *Solution:* Check the failed action's inputs in run history. Make sure all fields are filled and data types match. For complex data work, see [working with data operations and variables](/products/pro/integrations/middleware/power-automate/working-with-data-operations-and-variables/). * **Logic errors:** The flow runs but gives wrong results? Your conditions or expressions need fixing. * *Solution:* Review your [conditional logic](/products/pro/integrations/middleware/power-automate/using-conditional-logic-in-power-automate/) and [expressions](/products/pro/integrations/middleware/power-automate/advanced-conditions-and-expressions/). Add "Compose" actions to see what values your expressions actually produce during runs. * **API limits/throttling:** Making too many calls too quickly? Services (including Tallyfy) will throttle you. * *Solution:* Reduce the number of calls, add delays between actions, and check the [API](/products/pro/integrations/open-api/) documentation for specific rate limits. * **Interpreting error messages:** Error messages in the run history usually tell you exactly what went wrong. Read them! * **Using "Peek code" and "Compose":** * **Peek code:** Click the ellipsis (...) on any action and select **Peek code** to see its JSON structure. Helpful for understanding how Tallyfy expects data. * **Compose action:** Your best debugging friend. Add a Compose action ([details here](/products/pro/integrations/middleware/power-automate/working-with-data-operations-and-variables/)) to see what any expression or dynamic content actually contains when the flow runs. ## Best practices for managing Tallyfy-Power Automate flows * **Clear naming:** Give your flows, triggers, and actions descriptive names. "Tallyfy New Employee Onboarding" beats "Flow 1" every time. * **Regular review:** Check run history weekly for your critical flows - especially those automating important Tallyfy [processes](/products/pro/tracking-and-tasks/processes/). * **Documentation:** Complex flows with lots of [conditional logic](/products/pro/integrations/middleware/power-automate/using-conditional-logic-in-power-automate/) or [expressions](/products/pro/integrations/middleware/power-automate/advanced-conditions-and-expressions/)? Write down how they work. Future you will appreciate it. * **Connection security:** Keep your [Tallyfy connector](/products/pro/integrations/middleware/power-automate/how-can-i-integrate-tallyfy-with-microsoft-power-automate/) and other connections secure. Consider service accounts for flows that shouldn't depend on individual user accounts. * **Failover planning:** What's your backup plan if a critical flow fails? Set up alerts and document manual workarounds for mission-critical automations. Stay on top of these practices, and your Tallyfy automations will run smoothly. - **[Managing files with Power Automate](https://tallyfy.com/products/pro/integrations/middleware/power-automate/managing-files-with-power-automate/)**: Power Automate enables full file management for Tallyfy workflows by automating document creation sharing and archiving through connectors like SharePoint and OneDrive while supporting triggers for file events and actions for file operations to enhance process efficiency. ## Manage files with Power Automate You need file management in Tallyfy - documents get created, shared, and archived constantly throughout your [processes](/products/pro/tracking-and-tasks/processes/). That's reality. Power Automate gives you the automation tools to handle these files without thinking about it. Your documents stay organized and connected to your other business systems. No more manual file shuffling. Everything stays where it should. ### Which file management connectors work best with Tallyfy? Power Automate connects to pretty much any file storage service you're using. Here's what matters. These [connectors](/products/pro/integrations/middleware/power-automate/understanding-power-automate-basics/) work best with Tallyfy: * **SharePoint:** Perfect when your team collaborates on documents within Tallyfy [processes](/products/pro/tracking-and-tasks/processes/) * **OneDrive for Business:** Works when individuals need their files synced with Tallyfy locations You've got other options too - Dropbox, Google Drive, FTP. The concepts stay the same. Want to know which triggers actually matter for Tallyfy file automation? These ones: * `When a file is created (properties only)` - fires when someone drops a document in your Tallyfy SharePoint library * `When a file is created or modified (properties only)` * `When a file is created in a folder` And here are the actions you'll use constantly: * `Create file` * `Copy file` * `Move file` * `Get file content` * `Get file properties` * `Delete file` ## Use cases for file management with Tallyfy Let's talk real scenarios where file automation makes your Tallyfy [processes](/products/pro/tracking-and-tasks/processes/) actually work better: * **Archiving Tallyfy-generated documents:** Picture this - someone completes a [task](/products/pro/tracking-and-tasks/tasks/) and uploads their final report through a [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/). That completion fires a [webhook](/products/pro/integrations/webhooks/). Power Automate catches it and automatically archives the file to SharePoint. Done. * **Attaching files to Tallyfy tasks automatically:** Drop a new contract in SharePoint, and Power Automate instantly creates a "Review Contract" [task](/products/pro/tracking-and-tasks/tasks/) in your Tallyfy "Legal Review" [process](/products/pro/tracking-and-tasks/processes/). The contract's already attached. Your lawyers get notified. It just works. * **Triggering Tallyfy processes from file events:** Someone saves a sales proposal to your monitored OneDrive folder? Power Automate spots it and launches your "Sales Proposal Review" [procedure template](/products/pro/documenting/templates/) in Tallyfy - with the file link already populated in the launch form. ## Building an example file management flow for Tallyfy Here's a real example you can build in 10 minutes. Your "Project Completion" [process](/products/pro/tracking-and-tasks/processes/) has a final [task](/products/pro/tracking-and-tasks/tasks/) where users upload their closure report PDF. You want that report automatically archived to SharePoint when they're done. Let's build it. ## Tips for effective file automation with Tallyfy * **Clear folder structures:** Keep your SharePoint/OneDrive organized. Trust me - it makes Power Automate setup way easier when you know exactly where Tallyfy files should go. * **Permissions management:** Your Power Automate connection needs the right permissions for file operations. Check this first or you'll waste 30 minutes troubleshooting. * **File naming conventions:** Be consistent. Stick the Tallyfy [process](/products/pro/tracking-and-tasks/processes/) or [task](/products/pro/tracking-and-tasks/tasks/) ID in your filename (like `ProcessID_ReportName.pdf`). You'll thank yourself later. * **Use Tallyfy's capabilities:** Folder monitoring is fine, but Tallyfy's [Open API](/products/pro/integrations/open-api/) and [webhooks](/products/pro/integrations/webhooks/) give you way more control. Use them. * **Error handling:** Files go missing. Formats get weird. Add error handling to your flows so they don't just fail silently. - **[Triggering flows manually (button flows)](https://tallyfy.com/products/pro/integrations/middleware/power-automate/triggering-flows-manually-button-flows/)**: Instant flows in Power Automate enable users to manually trigger Tallyfy actions like launching processes creating tasks and collecting data through button presses in mobile apps or web portals. Most Power Automate flows run automatically to support your Tallyfy [processes](/products/pro/tracking-and-tasks/processes/). But sometimes you need to kick off an automation manually - right when you need it. These are **instant flows**, often called **button flows** since you trigger them by pressing a button in the Power Automate mobile app or web portal. ## What are instant (button) flows for Tallyfy? Instant flows are workflows you start manually to perform actions in Tallyfy. No waiting for external events. You press the button, they run. Perfect for: * **Ad-hoc Tallyfy tasks:** Those irregular actions you still want to standardize * **Quick Tallyfy actions:** Repetitive tasks you're tired of doing manually - one click and done * **Flows requiring user input:** When you need to collect specific info before Tallyfy automation kicks in ## Why use button flows with Tallyfy? Button flows give you on-demand control over your Tallyfy [processes](/products/pro/tracking-and-tasks/processes/) and [tasks](/products/pro/tracking-and-tasks/tasks/). Here's what you can do: * **Launch Tallyfy [processes](/products/pro/tracking-and-tasks/processes/) in seconds:** Start any [procedure template](/products/pro/documenting/templates/) right from your phone. The button flow can ask for initial info to pre-fill your launch [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) * **Log quick notes or tasks:** Create a button that instantly adds follow-up [tasks](/products/pro/tracking-and-tasks/tasks/) to your [Tasks view](/products/pro/tracking-and-tasks/tasks-view/) or drops a one-off task into any active [process](/products/pro/tracking-and-tasks/processes/) * **Send templated communications:** Set up a button for standard reminder emails about overdue [tasks](/products/pro/tracking-and-tasks/tasks/) (though honestly, automatic reminders usually work better) * **Collect data on the fly:** Use input fields to gather information that populates [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) when you launch a [process](/products/pro/tracking-and-tasks/processes/) or create a [task](/products/pro/tracking-and-tasks/tasks/) ## Creating an example button flow for Tallyfy Let's build a real example - a button flow that logs new sales leads into Tallyfy. You'll input the lead's name, email, and source. The flow then launches your "Sales Lead Intake" [procedure template](/products/pro/documenting/templates/). ## Running your Tallyfy button flow You've got two ways to run your button flow: * **From the web portal:** Navigate to **My flows**, find your flow, click **Run**, fill in the inputs, and click **Run flow** * **From your phone:** Open the Power Automate app, tap the **Buttons** tab, find your flow, tap it, enter the details, and go That's it. The flow runs, launches your Tallyfy [process](/products/pro/tracking-and-tasks/processes/), and pings you with a notification (if you set one up). ## Tips for Tallyfy button flows * **Keep inputs minimal:** If you're using these on mobile, fewer fields mean faster execution. Nobody likes typing on phones * **Name them clearly:** "Log Sales Lead" beats "Flow 1" every time * **Stack your actions:** After the Tallyfy action runs, why not add an email notification or Teams message? Get more done with one button press * **Think twice about manual triggers:** Could this process run automatically instead? Sometimes a scheduled or event-based trigger makes more sense than another button to remember - **[Understanding Power Automate basics](https://tallyfy.com/products/pro/integrations/middleware/power-automate/understanding-power-automate-basics/)**: Microsoft Power Automate enables workflow automation by connecting Tallyfy with various business applications through triggers and actions while Tallyfy manages human-centric processes and Power Automate handles system integrations and repetitive micro-tasks. ## What are the Power Automate basics for Tallyfy integration? Microsoft Power Automate connects Tallyfy with the other business apps you use every day. It's a workflow automation tool that makes these connections seamless. What does Power Automate do best? File syncing, sending notifications, collecting data, and automating those repetitive tasks that eat up your time. It streamlines how your tools work with Tallyfy [processes](/products/pro/tracking-and-tasks/processes/) - and you'll spend way less time on manual work. Think of Power Automate as a tool that responds to triggers - an event that starts an automation - and then performs a series of actions. Here's a real example: when a client email arrives with a contract attachment, Power Automate automatically saves that file to SharePoint and creates a Tallyfy [task](/products/pro/tracking-and-tasks/tasks/) for your legal team to review it. Tallyfy remains your go-to platform for managing [processes](/products/pro/tracking-and-tasks/processes/) and making sure people complete their tasks. Power Automate handles the automation *around* those processes - connecting Tallyfy to the other systems you can't live without. ### Why should I integrate Power Automate with Tallyfy? Tallyfy and Power Automate work incredibly well together. Let me explain why. Tallyfy focuses on what it does best: helping people work through structured [processes](/products/pro/tracking-and-tasks/processes/) together. You define the steps, track progress, and collaborate smoothly. Power Automate picks up the system-to-system work - those repetitive micro-tasks that happen before, during, or after your Tallyfy workflows. When you combine them? That's when things get efficient. Tallyfy handles the human side, Power Automate handles the automation side. Here's what this looks like in practice: * **Trigger Tallyfy workflows from external events:** When a new lead is added to your CRM (like Salesforce or HubSpot), a Power Automate flow can automatically launch a specific Tallyfy [procedure template](/products/pro/documenting/templates/), such as "New Client Onboarding," ensuring a standardized follow-up within Tallyfy. * **Update external systems based on Tallyfy progress:** When a critical [task](/products/pro/tracking-and-tasks/tasks/) in a Tallyfy process, like "Invoice Approved," is completed, Power Automate can update your accounting software (e.g., QuickBooks, Xero). * **Enhance notifications:** While Tallyfy has its own robust notifications, Power Automate can extend these. For example, send an SMS to a field technician when an urgent Tallyfy task is assigned to them, or post a custom message to a specific Microsoft Teams channel based on a Tallyfy event. To make all this happen, Tallyfy has a dedicated [connector for Power Automate](/products/pro/integrations/middleware/power-automate/how-can-i-integrate-tallyfy-with-microsoft-power-automate/). You can also check out the [Tallyfy Connector page on Microsoft Learn](https://learn.microsoft.com/en-us/connectors/tallyfy/) (though you'll find more practical guidance right here in our docs). ## Core Power Automate terminology for Tallyfy users You'll need to know these Power Automate terms to make the most of your Tallyfy integration: * **Flows:** This is the core of Power Automate. A flow is an automated workflow composed of a trigger and one or more actions, often interacting with Tallyfy. * **Cloud Flows:** These are common and run in Microsoft's cloud infrastructure. * *Automated flows:* These start automatically when a specific event occurs. For example, if a Tallyfy [process](/products/pro/tracking-and-tasks/processes/) step involves saving a document to a designated SharePoint folder, an automated flow can trigger when that new file is created. * *Instant flows (Button flows):* These are initiated manually by a user, typically by clicking a button. For instance, a sales representative could use an instant flow to quickly launch a Tallyfy "Client Demo Request" [process](/products/pro/tracking-and-tasks/processes/). You can learn more about [triggering flows manually](/products/pro/integrations/middleware/power-automate/triggering-flows-manually-button-flows/). * *Scheduled flows:* These run at predetermined times. An example could be a scheduled flow that runs every morning to check for overdue Tallyfy [tasks](/products/pro/tracking-and-tasks/tasks/) and sends a summary report to a manager. * **Desktop Flows (Briefly):** These are used for Robotic Process Automation (RPA), allowing you to automate tasks on a Windows desktop. This is covered in more detail in our article on [RPA with Power Automate](/products/pro/integrations/middleware/power-automate/introduction-to-rpa-with-power-automate/). * **Connectors:** These are bridges that allow Power Automate to communicate with different applications, including the [Tallyfy connector](/products/pro/integrations/middleware/power-automate/how-can-i-integrate-tallyfy-with-microsoft-power-automate/) which is essential for integrating with your Tallyfy account. Other connectors exist for Microsoft services (Outlook, SharePoint) and third-party services. * **Triggers:** A trigger is the specific event that starts a flow. Examples include "When a new email arrives" (Outlook connector), "When a file is created in a folder" (SharePoint connector), or "When a Tallyfy task is completed" (using the Tallyfy connector). You can also use Tallyfy [webhooks](/products/pro/integrations/webhooks/) in conjunction with Power Automate's HTTP connector to trigger flows based on a wide array of events in Tallyfy. * **Actions:** These are the operations a flow performs after it's triggered. For Tallyfy, actions could include "Create a Tallyfy task," or interacting with other systems based on Tallyfy data. * **Conditions:** These allow your flows to make decisions based on data, including data from Tallyfy. This is covered in [using conditional logic in Power Automate](/products/pro/integrations/middleware/power-automate/using-conditional-logic-in-power-automate/). * **Expressions (Briefly):** These are formulas for more advanced data manipulation. We explore expressions in [advanced conditions and expressions in Power Automate](/products/pro/integrations/middleware/power-automate/advanced-conditions-and-expressions/). * **Dynamic Content:** This refers to data from previous steps in your flow (from Tallyfy triggers or other actions) that you can use in subsequent actions. For example, when a Tallyfy task completion triggers a flow, the task's details (ID, name, completed by) are available as dynamic content. ## Power Automate interfaces overview You'll primarily interact with Power Automate through these interfaces when setting up integrations for Tallyfy: * **Web Portal (flow.microsoft.com):** The main hub for creating, managing, and [monitoring your cloud flows](/products/pro/integrations/middleware/power-automate/managing-and-monitoring-power-automate-flows/) that connect to Tallyfy. * **Mobile App (iOS and Android):** Useful for running instant (button) flows that might interact with Tallyfy. * **Power Automate Desktop:** This application is for creating and managing [desktop flows (RPA)](/products/pro/integrations/middleware/power-automate/introduction-to-rpa-with-power-automate/). ## How these concepts enhance Tallyfy Once you understand these building blocks, you can create automations that seriously enhance your Tallyfy [processes](/products/pro/tracking-and-tasks/processes/). Want a concrete example? An **automated flow** monitors your support inbox using Outlook's **connector**. The **trigger** fires when a new email arrives. If the subject line contains "Urgent Support Request" (that's your **condition**), the flow takes **action** - it uses the Tallyfy **connector** to create a high-priority [task](/products/pro/tracking-and-tasks/tasks/) in your support [process](/products/pro/tracking-and-tasks/processes/). The task automatically includes **dynamic content** from the email - who sent it, what they wrote, everything your team needs. Master these basics, and you'll connect Tallyfy to your entire digital ecosystem. Power Automate becomes the bridge that makes it all work together. - **[Using AI Builder in Power Automate](https://tallyfy.com/products/pro/integrations/middleware/power-automate/using-ai-builder-in-power-automate/)**: AI Builder adds intelligence to Power Automate flows by providing pre-built models for text recognition and sentiment analysis plus trainable custom models for form processing and predictions that can automatically extract data from documents and route Tallyfy tasks based on AI-analyzed content without requiring coding expertise. Want your Power Automate flows to understand text from Tallyfy [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/), recognize images attached to [tasks](/products/pro/tracking-and-tasks/tasks/), or process documents that kick off a [process](/products/pro/tracking-and-tasks/processes/)? That's where **AI Builder** comes in. It's a feature inside Power Automate that lets you add AI capabilities to your automations without writing complex code - perfect for making your Tallyfy workflows smarter. ## What is AI Builder? AI Builder lets you add intelligence to your Power Automate flows (and Power Apps) without being a data scientist. You get pre-built AI models ready for common scenarios, plus the ability to create custom models tailored to your specific Tallyfy data. Here's the thing - AI Builder shines when you need to interpret unstructured data. Think about emails that should trigger a Tallyfy task, or scanned forms that need to launch a [process](/products/pro/tracking-and-tasks/processes/). It can even predict outcomes based on your historical Tallyfy data. The result? Smarter integrations that actually understand your content. ## Types of AI Builder models relevant to Tallyfy AI Builder offers several models that work great with Tallyfy workflows: * **Pre-built Models (Ready to Use):** Microsoft trained these models, so you can use them right away with Tallyfy. * **Text Recognition (OCR):** Pulls text from images and PDFs. Perfect for processing scanned forms that need to feed into a Tallyfy [process](/products/pro/tracking-and-tasks/processes/), making the content available for [tasks](/products/pro/tracking-and-tasks/tasks/) downstream. * **Sentiment Analysis:** Detects whether text is positive or negative. Great for analyzing customer feedback from Tallyfy [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) - you can route angry customers to a priority queue instantly. * **Key Phrase Extraction:** Finds the main points in text. Handy for summarizing lengthy notes from a Tallyfy [task](/products/pro/tracking-and-tasks/tasks/). * **Language Detection:** Identifies which language someone's using. Essential if your Tallyfy [processes](/products/pro/tracking-and-tasks/processes/) handle multilingual communications. * **Business Card Reader:** Grabs contact info from business card photos, then automatically fills in fields for your Tallyfy "Contact Creation" [process](/products/pro/tracking-and-tasks/processes/). * **Receipt Processing:** Extracts expense data from receipts, feeding directly into your expense approval [process](/products/pro/tracking-and-tasks/processes/) in Tallyfy. * **Custom Models (Train with Your Own Data):** You'll need to train these models using your actual data for your specific Tallyfy use case. * **Form Processing:** Teach the model to understand your invoices, purchase orders, or any forms that kick off a Tallyfy [process](/products/pro/tracking-and-tasks/processes/). Works brilliantly with documents that don't follow a standard template. * **Object Detection:** Train it to spot specific objects in images. Think quality control [processes](/products/pro/tracking-and-tasks/processes/) where team members upload photos to [tasks](/products/pro/tracking-and-tasks/tasks/) - the AI can check if all required parts are visible. * **Prediction:** Uses your historical Tallyfy data to predict future outcomes. For instance, it can estimate whether a [process](/products/pro/tracking-and-tasks/processes/) will meet its SLA deadline based on the initial [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) submitted. * **Category Classification (Text):** Automatically sorts text from Tallyfy [tasks](/products/pro/tracking-and-tasks/tasks/) or [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) into categories you define. Support tickets logged through Tallyfy? They'll get tagged automatically. ## Using a pre-built AI Builder model: sentiment analysis with Tallyfy data Want to see this in action? Let's use AI Builder's Sentiment Analysis to automatically process customer feedback from a Tallyfy [task](/products/pro/tracking-and-tasks/tasks/). **Scenario:** Your "Customer Feedback Collection" [process](/products/pro/tracking-and-tasks/processes/) has a [task](/products/pro/tracking-and-tasks/tasks/) where customers type their feedback into a [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/). You need to analyze whether they're happy or upset - then route accordingly within Tallyfy. ## Training a custom AI Builder model: form processing with Tallyfy (conceptual overview) Custom models take more work to set up, but they're tailored exactly to your Tallyfy data. Here's how Form Processing handles scanned documents that launch Tallyfy [processes](/products/pro/tracking-and-tasks/processes/). **Scenario:** You receive purchase orders as scanned PDFs - all different formats from various suppliers. Each PO has the essentials: PO Number, Customer Name, Items, and Quantities. You're tired of manual data entry, so you want these to automatically launch your "Order Fulfillment" [process](/products/pro/tracking-and-tasks/processes/) in Tallyfy. ## Licensing and considerations for AI Builder with Tallyfy * **Licensing:** AI Builder needs its own Power Platform credits - these aren't included with standard Power Automate licenses. You'll burn through credits each time your models process Tallyfy data. * **Effort:** Pre-built models? Easy. Custom models? Plan to spend time collecting sample documents from your Tallyfy [processes](/products/pro/tracking-and-tasks/processes/), tagging them carefully, and training the model. It's worth it though. * **Accuracy:** Your custom model is only as good as your training data. Feed it 100 varied examples, and it'll handle real-world Tallyfy data beautifully. Give it 5 similar samples? Don't expect miracles. ## How AI Builder can make Tallyfy processes smarter Here's what happens when you combine AI Builder with your Tallyfy workflows: * **Reduce manual data entry:** Emails and documents get processed automatically - their data flows straight into Tallyfy [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/). No more typos, no more tedious copying between systems. * **Gain deeper insights:** Customer comments in Tallyfy [tasks](/products/pro/tracking-and-tasks/tasks/)? Support notes buried in text? AI Builder analyzes them all, pulling out sentiment and key information you'd otherwise miss. * **Intelligent routing:** Before data even reaches Tallyfy, AI analyzes it and decides where it should go. Urgent issues get fast-tracked, routine requests follow standard paths. * **Proactive actions:** Prediction models watch your Tallyfy [processes](/products/pro/tracking-and-tasks/processes/) and spot trouble coming. That order heading for a delay? You'll know 3 days early. Adding AI Builder to your Power Automate flows transforms Tallyfy from a workflow tool into an intelligent business partner that actually understands your content. - **[Using conditional logic in Power Automate](https://tallyfy.com/products/pro/integrations/middleware/power-automate/using-conditional-logic-in-power-automate/)**: Power Automate's conditional logic enables automated flows to make intelligent decisions based on Tallyfy data using IF-THEN structures Switch controls and nested conditions to create adaptive workflows that respond differently to various task statuses form field values and process conditions. Automated workflows become powerful when they can make decisions. Power Automate's **conditional logic** lets you build flows that adapt to different situations and perform different actions based on specific criteria from your Tallyfy [processes](/products/pro/tracking-and-tasks/processes/). You'll create flexible automations that actually think. ## Introduction to conditional logic for Tallyfy integrations Conditional logic lets your Power Automate flow answer questions about Tallyfy data - then act on the answers. When a condition related to a Tallyfy [task](/products/pro/tracking-and-tasks/tasks/) or [process](/products/pro/tracking-and-tasks/processes/) is true, the flow takes one path. False? It takes another. Why does this matter? Picture a customer support [process](/products/pro/tracking-and-tasks/processes/) in Tallyfy. Your flow checks the "Priority" [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) in each [task](/products/pro/tracking-and-tasks/tasks/). High priority? The flow escalates it immediately. Low priority? It logs it for routine follow-up. All automatic. ## The "Condition" control for Tallyfy data ## Building a flow with simple conditional logic for Tallyfy Here's a real scenario: When someone completes a Tallyfy [task](/products/pro/tracking-and-tasks/tasks/), you want to check the "Approval Outcome" [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) and send different email notifications based on what it says. ## Visualizing the conditional flow This diagram shows how Power Automate processes Tallyfy task data through conditional logic to route notifications appropriately. [Diagram removed for brevity] **What to notice:** - The diamond shape represents the decision point where your flow evaluates the Tallyfy form field value - Two distinct paths show how different outcomes trigger different email actions automatically - Each step in the flow corresponds directly to the numbered instructions above - making the logical flow instantly clear ## Handling multiple conditions (AND/OR) for Tallyfy data You'll often need to check multiple pieces of Tallyfy data at once. * **Adding rows:** Inside a Condition, click **+ Add** > **Add row**. * **AND logic:** Default for multiple rows - all conditions must be true. * **OR logic:** Change the operator at the top of the conditions group to OR - any single condition being true is enough. *Tallyfy Example (AND):* IF Tallyfy [task](/products/pro/tracking-and-tasks/tasks/) Priority ([form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/)) is "High" **AND** its Due Date (from Tallyfy) is in the past, THEN send an escalation alert. ## Nested conditions for complex Tallyfy logic Want more complex decision trees? Place a Condition control inside another Condition's branch. *Example:* First, check if the Tallyfy [process](/products/pro/tracking-and-tasks/processes/) type is "Sales Order." If yes, add a nested condition to check whether the order value (a Tallyfy [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/)) exceeds $10,000. Things getting messy? Switch to a Switch control instead (see [advanced conditions and expressions](/products/pro/integrations/middleware/power-automate/advanced-conditions-and-expressions/)). ## Introduction to Switch control (for multiple distinct options from Tallyfy) The **Switch** control beats multiple nested conditions when you're checking one Tallyfy value against many options. We cover this in detail in our [advanced conditions and expressions](/products/pro/integrations/middleware/power-automate/advanced-conditions-and-expressions/) article. * **Structure:** Pick a value to switch ON (like dynamic content from a Tallyfy [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/)). Create multiple **CASE** branches - one for each possible Tallyfy value. The **DEFAULT** branch catches everything else. *Tallyfy Example:* A Tallyfy [task](/products/pro/tracking-and-tasks/tasks/) has a [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) "Support Ticket Category" with values like "Billing Issue," "Technical Problem." * SWITCH ON Tallyfy "Support Ticket Category": * CASE "Billing Issue": Action - Notify finance. * CASE "Technical Problem": Action - Create urgent [task](/products/pro/tracking-and-tasks/tasks/) in a Tallyfy "Tech Support" [process](/products/pro/tracking-and-tasks/processes/). * DEFAULT: Action - Notify general support. ## Tips for using conditions with Tallyfy data * **Data types:** Make sure data types match. Use [expressions](/products/pro/integrations/middleware/power-automate/advanced-conditions-and-expressions/) (like `int()`) to convert Tallyfy text field values when comparing to numbers. * **Case sensitivity:** For case-insensitive text comparisons of Tallyfy data, use expressions like `toLower()`. * **Leverage Tallyfy outputs:** Data from Tallyfy [connector](/products/pro/integrations/middleware/power-automate/how-can-i-integrate-tallyfy-with-microsoft-power-automate/) triggers and actions should drive your conditional logic. * **Test all paths:** Test every single branch with different Tallyfy data inputs. Really. - **[Working with data operations and variables in Power Automate](https://tallyfy.com/products/pro/integrations/middleware/power-automate/working-with-data-operations-and-variables/)**: Power Automate offers robust data handling capabilities including variables storage loops parsing and transformation features to effectively process and manipulate Tallyfy workflow information for automated business processes. Your Power Automate flows need to handle real data - lots of it. When you're pulling information from Tallyfy, you'll work with collections of [tasks](/products/pro/tracking-and-tasks/tasks/), data from [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/), and everything in between. You need ways to store values temporarily, transform data, and process multiple items at once. That's where data operations and variables come in. ## Understanding variables in Power Automate for Tallyfy integrations Think of variables as temporary storage boxes. They hold data while your flow runs, and that data can change as the flow progresses through different steps. * **Why use variables with Tallyfy integrations?** * Store intermediate results from calculations or data lookups related to Tallyfy items. * Count Tallyfy [tasks](/products/pro/tracking-and-tasks/tasks/) meeting certain criteria. * Accumulate data (like a list of Tallyfy task names) before sending it to Tallyfy or another system. * Control loop behavior or conditional logic based on a changing value from Tallyfy data. * **Types of variables:** Power Automate supports several data types: * **Boolean:** True or false. * **Integer:** Whole numbers (e.g., 10, -5). * **Float:** Numbers with decimals (e.g., 3.14). * **String:** Text. * **Array:** A list or collection of items (e.g., a list of Tallyfy task names). * **Object:** A complex data structure with key-value pairs (often representing JSON objects). * **Common variable actions:** * **Initialize variable:** Always comes first - declares a variable, names it, sets its type and initial value * **Set variable:** Updates the value after initialization * **Increment variable / Decrement variable:** Adds or subtracts 1 (perfect for counters) * **Append to string variable:** Tacks text onto the end of a string * **Append to array variable:** Adds items to your list ## Looping through Tallyfy data (Apply to each) Got multiple items to process? The **Apply to each** control handles that. * **How it works:** Feed it an array of Tallyfy items. It runs your actions once for every single item. * **Automatic usage:** Power Automate's pretty smart - it'll add an "Apply to each" loop automatically when you select dynamic content that's a list (like rows from a Tallyfy table [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/)) * **Explicit usage:** You can also add an "Apply to each" control yourself and point it to array data from an earlier step **Tallyfy example:** Let's say you have a [task](/products/pro/tracking-and-tasks/tasks/) with a table-type [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) where users list equipment needed for a project. When you pull this task's details through the Tallyfy [connector](/products/pro/integrations/middleware/power-automate/how-can-i-integrate-tallyfy-with-microsoft-power-automate/) or [API](/products/pro/integrations/open-api/), that table comes back as an array. Perfect scenario for looping. Use "Apply to each" to go through every row. Maybe you create purchase orders in your ERP system for each item. Or add them as checklist items to another Tallyfy task. The loop handles it row by row. ## Data parsing: Parse JSON action for Tallyfy data Here's the reality - Tallyfy [webhooks](/products/pro/integrations/webhooks/) and [API](/products/pro/integrations/open-api/) responses speak JSON. You need to understand that language. * **Why parse JSON from Tallyfy?** Power Automate receives JSON strings from Tallyfy (think webhook payloads or API responses). The **Parse JSON** action turns that text into actual objects and properties you can work with. No parsing means no access to the data inside. * **Using the "Parse JSON" action:** 1. Add the **Parse JSON** action from Data Operations 2. **Content:** Drop in your JSON string from Tallyfy 3. **Schema:** This defines the structure. Here's the shortcut - click **Generate from sample** and paste in real JSON from a Tallyfy webhook or API call. Done. :::caution[Field mapping limitations] When working with Tallyfy form field data in Power Automate: - Complex field types (dropdowns, checkboxes) return structured JSON objects, not simple values - Dropdown fields return objects with properties like `id`, `text`, and `value` - To access the display text of a dropdown, use expressions like `body('Parse_JSON')?['fieldName']?['text']` - Table fields return arrays that require loops or indexing to access individual rows - Always use Parse JSON action first to properly structure Tallyfy data before mapping ::: **Tallyfy example:** Someone launches a [process](/products/pro/tracking-and-tasks/processes/) in Tallyfy. Your [webhook](/products/pro/integrations/webhooks/) fires off a JSON payload to Power Automate. Inside that JSON? Everything you need - process name, who started it, all the launch form data. But it's just text until you parse it. Run it through "Parse JSON" and suddenly you can grab the initiator's email for notifications, use the form data to update other systems, whatever you need. **Handling Tallyfy field types in Power Automate:** - **Text fields**: Straight mapping as strings - easy - **Dropdown fields**: Need the display text? Use `item()?['fieldName']?['text']` after parsing - **Checkbox fields**: You get an array of what's checked. Loop through it or grab specific items by index - **Table fields**: Each row is an object in an array. You'll need loops here - **Date fields**: Comes as ISO format. Make it pretty with `formatDateTime()` ## Data transformation for Tallyfy data: Create CSV Table and Create HTML Table Need to turn Tallyfy data into reports? These two actions have you covered: * **Create CSV Table:** Feed it an array of Tallyfy task details. Get back a CSV string ready for Excel * **Create HTML Table:** Same idea, but outputs an HTML table you can drop right into an email **Tallyfy use cases:** * Pull all overdue [tasks](/products/pro/tracking-and-tasks/tasks/) for a project using the Tallyfy [connector](/products/pro/integrations/middleware/power-automate/how-can-i-integrate-tallyfy-with-microsoft-power-automate/) or [API](/products/pro/integrations/open-api/) * Run them through **Create CSV Table** for a downloadable report * Or use **Create HTML Table** to email a nicely formatted summary to stakeholders ## Combining variables, loops, and data operations: a Tallyfy example Time to put it all together with a real workflow. **Scenario:** Your team lead wants a daily email showing all their Tallyfy [tasks](/products/pro/tracking-and-tasks/tasks/) due today. Nice HTML format, arrives at 8 AM sharp. ## Tips for Tallyfy users working with data operations * **Initialize early:** Put all your variable initializations right at the start. Keeps things organized. * **Array structures from Tallyfy:** Watch out for arrays - they're everywhere in Tallyfy data. Table [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/)? Arrays. Multiple tasks from the [API](/products/pro/integrations/open-api/)? Arrays. You'll be using "Apply to each" a lot. * **Inspect with "Compose":** Can't figure out what your data looks like? Drop in a "Compose" action and output your variable or Tallyfy data. It's like console.log for Power Automate (yes, debugging is that simple). - **[Working with email automation in Power Automate](https://tallyfy.com/products/pro/integrations/middleware/power-automate/working-with-email-automation-in-power-automate/)**: Power Automate integrates email services like Outlook 365 with Tallyfy workflows to automatically trigger processes from incoming emails extract data and attachments and send personalized notifications based on task completions or process milestones. Email takes up way too much time. Here's the thing - Power Automate can handle your email tasks automatically and connect them directly to your Tallyfy [processes](/products/pro/tracking-and-tasks/processes/). You'll get timely actions, data capture, and notifications for your Tallyfy [tasks](/products/pro/tracking-and-tasks/tasks/) without the manual hassle. ## Email connectors in Power Automate for Tallyfy workflows Power Automate provides several [connectors](/products/pro/integrations/middleware/power-automate/understanding-power-automate-basics/) for email services. **Outlook 365** is the most popular one. You've also got Gmail, Outlook.com, and SMTP options. We'll use Outlook 365 examples here (it's what most businesses run), but these automation principles work the same way across all email connectors when you're connecting to Tallyfy. ## Common email automation scenarios for Tallyfy Want to cut your email processing time by 80%? These are the automation scenarios that actually move the needle: * **Reading email content to trigger Tallyfy actions:** Set up flows that watch for specific emails. When they arrive, Power Automate extracts data from the subject or body - then automatically launches a Tallyfy [process](/products/pro/tracking-and-tasks/processes/), creates a [task](/products/pro/tracking-and-tasks/tasks/), or updates existing work. * *Example:* Supplier sends an invoice email. Power Automate grabs the invoice details and instantly creates a "Process Invoice" [task](/products/pro/tracking-and-tasks/tasks/) in your Tallyfy finance [process](/products/pro/tracking-and-tasks/processes/). The invoice data drops right into your Tallyfy [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/). Zero manual entry. * **Handling email attachments for Tallyfy:** Flows save attachments to SharePoint or OneDrive automatically. Then they link these files directly to the right Tallyfy [tasks](/products/pro/tracking-and-tasks/tasks/). * *Example:* Client emails you a project brief. Power Automate saves it to SharePoint and kicks off your Tallyfy "New Project Onboarding" [procedure template](/products/pro/documenting/templates/). The brief attaches itself to the first [task](/products/pro/tracking-and-tasks/tasks/). Your team sees it immediately. * **Sending automated emails based on Tallyfy events:** Trigger custom emails when things happen in Tallyfy - like [task](/products/pro/tracking-and-tasks/tasks/) completions or [process](/products/pro/tracking-and-tasks/processes/) milestones. Use the Tallyfy [connector](/products/pro/integrations/middleware/power-automate/how-can-i-integrate-tallyfy-with-microsoft-power-automate/) or [webhooks](/products/pro/integrations/webhooks/) to set this up. Pull data from Tallyfy [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) to personalize each message. * *Example:* Someone completes the "Send Welcome Pack" step in your "Customer Onboarding" [process](/products/pro/tracking-and-tasks/processes/). Power Automate fires off a personalized welcome email using the customer's name, company, and preferences straight from your Tallyfy [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/). ## Building an example email automation flow for Tallyfy Let's build something real. We'll create a flow that watches your shared mailbox (`orders@yourcompany.com`) for emails with "New Order Request" in the subject line. When one arrives, it launches your Tallyfy "New Order Processing" [procedure template](/products/pro/documenting/templates/) with all the order details filled in. Takes about 10 minutes to set up. ## Best practices for email automation with Tallyfy * **Be specific with triggers:** Use exact subject lines or sender addresses. You don't want flows firing for every email - that'll burn through your [API](/products/pro/integrations/open-api/) limits fast. * **Plan data extraction for Tallyfy:** Map out which email parts go where. Subject line to process name? Body text to description field? Decide before you build. * **Design Tallyfy templates for automation:** Create [procedure templates](/products/pro/documenting/templates/) with automation in mind. Use consistent field names like "CustomerEmail" not "email" or "Email" or "customer_email". Trust me on this one. * **Robust error handling:** What happens when that attachment's missing? Or the email format's weird? Build in fallbacks to keep your Tallyfy processes running smoothly. * **Test thoroughly:** Send test emails from different accounts, with various formats. Break it before your users do. ### Analytics - **[How Tallyfy Analytics works](https://tallyfy.com/products/pro/integrations/analytics/how-does-tallyfy-analytics-process-my-data/)**: Tallyfy Analytics transforms workflow data through a five-step pipeline that detects events extracts process details converts data to Apache Parquet format stores it securely in Amazon S3 and provides AWS credentials for connecting business intelligence tools like Power BI and Tableau through Amazon Athena. ## How Tallyfy Analytics prepares your data Tallyfy Analytics transforms your workflow data into a format that business reporting tools can understand. Want to analyze your processes in Power BI or Tableau? Here's exactly how your data travels from Tallyfy to those tools. ### Overview of the Data Process Your data goes through five steps to become analytics-ready: 1. **Detecting an event**: Tallyfy watches for important changes - task completions, status updates, and more. 2. **Extracting the data**: We capture every detail about the process where the event occurred. 3. **Converting the format**: The data gets converted to Apache Parquet[^1] - a format built for fast analysis. 4. **Storing securely**: Everything lands in your private Amazon S3 storage bucket. 5. **Providing access**: You receive AWS credentials to connect your favorite BI tools. ### How the process works in detail #### 1. Spotting an event Tasks get completed. Statuses change. Forms get submitted. When these actions happen in Tallyfy, the system flags them as analytics events worth tracking. #### 2. Getting the data Every event triggers a complete process snapshot. We capture: - Basic process info (who owns it, status, start and end times) - Details about each task - Information submitted in form fields - Who was assigned to tasks - Comments added All this data initially gets saved as a CSV file - just like a spreadsheet you'd open in Excel. :::note[Timestamp storage format] All timestamps in the exported data are stored in ISO 8601 format without timezone information. This universal format ensures consistent data storage for reliable analysis across different timezones. When users view this data in Tallyfy's interface, timestamps are automatically converted to display in their personal timezone setting. ::: :::tip[Understanding time data] Task timestamps capture when work was assigned and completed - not how long someone actually worked on it. That "5-day" task might include a weekend, holidays, or just 30 minutes of actual effort spread across a busy week. For clean effort metrics, implement time tracking fields. Learn more: [how to track time spent on tasks](/products/pro/tutorials/how-to/track-time-in-tasks/#analytics-timestamps-inherit-these-challenges). ::: #### 3. Changing the format That CSV file won't cut it for serious analytics. Tallyfy automatically converts it to Apache Parquet format, which: - Analyzes significantly faster than CSV files - Takes up much less storage space - Works seamlessly with Power BI, Tableau, and other BI tools #### 4. Storing safely Your Parquet files land in a secure home: - **Amazon S3** handles the storage (yes, the same service Netflix uses) - You get a **private folder** - no one else can access it - **AWS security** protects everything with encryption at rest - Files stay available throughout your Tallyfy Analytics subscription #### 5. Allowing access for analysis Here's where the magic happens. Tallyfy gives you AWS IAM credentials - think of them as special keys to your data warehouse. With these credentials, your BI tools can: - Connect straight to your data through **Amazon Athena[^2]** - Run SQL queries to slice and dice your process information - Use familiar JDBC/ODBC connections (every BI tool supports these) - Build dashboards that actually answer your questions ### Technical Diagram Want to see the complete journey? This diagram maps out every step: ![Tallyfy Analytics data pipeline from API to BI tools](https://screenshots.tallyfy.com/tallyfy/pro/analytics-data-pipeline-diagram.png) ### Activating Analytics Ready to get started? A few things to know: - Data processing begins the moment Tallyfy Analytics activates on your account - not before - You'll receive your AWS IAM credentials right after activation - Connect your BI tools in under 10 minutes using standard drivers - Need data stored in a specific region or format? Contact Tallyfy support first [^1]: Columnar storage format optimized for analytics, widely supported by AWS, Azure, and Google Cloud [^2]: Serverless SQL query service that analyzes data directly in S3 without loading into a database - **[CSV file structure](https://tallyfy.com/products/pro/integrations/analytics/how-is-the-csv-file-structured-in-tallyfy/)**: Tallyfy exports running process data into 49-column CSV files containing tasks form answers comments and metadata organized in rows where each row represents a task form field or comment with columns grouped into process info task details assignments timing form fields and comments sections. ## Understanding the CSV Export Structure You can export any running process data into a CSV file - that's 49 columns[^1] of everything happening in your process. Tasks, form answers, comments. All of it lands in a spreadsheet you can analyze however you need. ### How to Export a Process to CSV 1. Open the running process you want to export. 2. Click **Settings** (usually in the top right). 3. Scroll down to the bottom of the settings panel. 4. Click **Export CSV**. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-export-csv.png) ### How the Data is Organized Here's the thing - your process has multiple layers (process details, tasks, fields within those tasks). The CSV flattens everything into rows. Each row represents one thing: a task, a form field, or a comment. *Note for Tallyfy Analytics users: The data you query using reporting tools (via Amazon Athena) is based on this same structure, just stored in a more efficient format (Parquet[^2]).* ### Understanding the Columns The 49 columns break down into logical groups: #### Process and template info (Columns 1-13) :::note[Template vs. Blueprint] Some column names use the term "Blueprint". That's the technical/API name for what you see as a "Template" in the Tallyfy app. ::: * **blueprint_id**: Template's unique ID. * **blueprint_name**: Template's name. * **blueprint_version**: Template's version number. * **process_id**: Unique ID for this specific run of the process. * **process_name**: Name given to this run of the process. * **process_tag**: Any tags added to this process run. * **process_owner**: Name of the person who owns this process run. * **process_owner_id**: ID of the process owner. * **total_tasks_in_process**: How many tasks are in the whole process. * **tasks_completed**: How many tasks are finished. * **process_status**: Current status (active, problem, or complete). * **process_last_modified**: Date/time the process was last updated. ⚠️ *This updates on any change (edits, archiving, tags) - not just completion. For accurate completion timestamps, use `process_completed_at` instead.* * **process_completed_at**: Exact date/time when the process was marked complete. This is the authoritative completion timestamp - use this for calculating process duration and completion metrics. Returns NULL for active/incomplete processes. #### Task info (Columns 14-27) * **type**: What kind of data this row represents (e.g., `process_task`, `process_task_data` for a form field, `process_task_comment` for a comment). * **has_form_fields**: Does the task in this row have form fields? (Yes/No). * **kick_off_task_id / name**: ID/Name if this row relates to the initial kick-off form. * **process_task_id**: Unique ID for this specific task instance. * **process_task_status**: Task status (e.g., shown, hidden, completed - *check exact values*). * **process_task_name**: Name of the task. * **process_task_alias**: A stable ID for this step from the template (handy for comparing across runs). * **process_task_data_id**: ID if this row is for a form field. * **process_task_data_name**: Name of the task this form field belongs to. * **process_task_comment_id**: ID if this row is for a comment. * **milestone_id**: Unique ID of the milestone attached to this task (if any). * **milestone_name**: Name of the milestone attached to this task (if any). * **milestone_position**: Position/order of the milestone in the process sequence. #### Assignment and timing info (Columns 28-36) * **user_assigned**: Names of assigned members/groups. * **assigned_user_id**: IDs of assigned members. * **guest_assigned**: Email of assigned guest. * **total_users_assigned**: Number of members assigned. * **total_guests_assigned**: Number of guests assigned. * **total_assignees**: Total people assigned. * **completed_by**: ID of person who completed the task. * **assigned_or_shown_on**: Date task appeared/was assigned. * **due_by**: Task deadline date/time. * **completed_on**: When the task was completed (also appears in Comments section). :::caution[NaN Values in Date Fields] When using Tallyfy Analytics with Power BI, Tableau, or other tools, you may see the string **"NaN"** in date fields like `completed_on`, `assigned_or_shown_on`, `due_by`, and `process_completed_at`. This happens when the original database value was NULL. **Why this occurs**: 1. NULL database values are exported to CSV 2. Pandas (Python data processing) converts NULL → NaN (Not a Number) 3. During Parquet conversion, NaN values become the literal string "NaN" 4. Your analytics tool sees "NaN" as text, not a valid date **How to handle in DAX (Power BI)**: ```dax FILTER( 'Query1', NOT(ISBLANK('Query1'[completed_on])) && 'Query1'[completed_on] <> "nan" ) ``` **How to handle in Tableau**: ```sql CASE WHEN completed_on = 'nan' OR completed_on IS NULL THEN NULL ELSE completed_on END ``` Always filter out both ISBLANK/NULL values AND the string "nan" to ensure accurate date calculations. ::: #### Form field info (Columns 37-40) *(These columns only have data if the row `type` is `process_task_data`)* * **no_of_form_fields**: How many fields are in the parent task. * **form_field_type**: Type of this specific field (text, date, dropdown, etc.). * **question_in_form_field**: The question/label for this field. * **answer_in_form_field**: The answer entered into this field. #### Comments and issues info (Columns 41-49) *(These columns often relate to rows where `type` is `process_task_comment` or provide summary counts on `process_task` rows)* * **issue_reported**: Was this comment reporting an issue? (Yes/No). * **no_of_issue_reported**: Total issues reported on the task. * **issue_resolved**: Was the reported issue resolved? (Yes/No). * **no_of_issue_resolved**: Total resolved issues on the task. * **total_comments**: Number of regular comments on the task. * **comment**: The text of the comment (if `type` is `process_task_comment`). * **last_modified**: When this row's data was last updated. ### Note on Dates for Reporting Tools Using Tallyfy Analytics with Power BI or Tableau? You'll need to format date columns in your SQL queries using Amazon Athena / Presto SQL functions. :::note[Timestamp handling] All timestamps in CSV exports and audit trails are stored on our server in ISO 8601 format[^3] without timezone information. In user-facing areas of Tallyfy, these universal timestamps are automatically converted to display in your personal timezone setting. Works great - consistent storage, accurate local display. ::: :::tip[Tracking actual work time] Want to track how long tasks actually take to complete (not just elapsed time)? Check out [how to track time spent on tasks](/products/pro/tutorials/how-to/track-time-in-tasks/). Form fields for hours and minutes will appear in your CSV exports, giving you clean data about actual effort versus calendar time. ::: ### Example CSV View Want to see what you're getting? Here's the exported data in a spreadsheet: ![CSV export spreadsheet with process data](https://screenshots.tallyfy.com/tallyfy/pro/analytics-csv-export-spreadsheet.png) [^1]: Each column represents a specific data point like process ID, task status, or form field answer [^2]: Columnar storage format optimized for analytics, typically 10x smaller than CSV with faster query performance [^3]: Standard datetime format like YYYY-MM-DDTHH:MM:SS, ensures consistent parsing across systems - **[Measure reading engagement with Google Analytics or Mixpanel](https://tallyfy.com/products/pro/integrations/analytics/how-to-set-up-google-analytics-integration-on-tallyfy/)**: Tallyfy integrates with Google Analytics and Mixpanel to track how teams use templates processes and documentation by configuring custom dimensions in GA4 or connecting a Mixpanel project token to capture detailed usage metrics like page views completion rates and engagement patterns. ## Tracking Template/Process Usage with Analytics Tools You can connect Tallyfy to web analytics tools like Google Analytics or Mixpanel. These tools show exactly how people in your organization - or guests[^1] - are using your Tallyfy documentation, templates, and processes. ### Why track usage? - **See what people use**: Find out which templates or documents are viewed most often - **Measure engagement**: Track exactly how long people spend on specific pages or steps - **Find popular processes**: Identify which workflows get used 50+ times a week (or barely at all) - **Understand usage**: Learn when teams access process information - mornings? Late nights? - **Check value**: See if using certain processes correlates with better results ## Setting up Google Analytics (GA) ### What you need - A Google Analytics account where you have admin rights - A Tallyfy Professional or Enterprise plan - Administrator permission in Tallyfy ### Step 1: Set up Custom Dimensions[^2] in Google Analytics *Important: Do this step first inside your Google Analytics account.* Tallyfy can't send data without these dimensions configured. 1. Log into Google Analytics 2. Go to **Admin** (gear icon) > **Data display** > **Custom definitions** > **Custom dimensions** 3. Click **Create custom dimension** and create these five dimensions: | Dimension Name | Scope | Event Parameter | |----------------|-------|-------------------| | User Name | User | user_name | | User Email | User | user_email | | Process Name | Event | process_name | | Event Type | Event | event_type | | Event Details | Event | event_details | ![Google Analytics custom dimensions configuration](https://screenshots.tallyfy.com/tallyfy/pro/analytics-ga-custom-dimensions.png) :::caution[Match settings EXACTLY!] The dimension names and event parameters must match the table above. Incorrect configuration will prevent data from flowing to your reports. ::: ### Step 2: Get your Google Analytics Measurement ID 1. In Google Analytics, go to **Admin** > **Data Streams** 2. Select your web data stream and copy your **Measurement ID** (it looks like G-XXXXXXXXXX) ### Step 3: Connect Tallyfy to Google Analytics That's it. Tallyfy now sends usage data (page views, events, the works) straight to your Google Analytics account. ## Tracking specific users with User ID in GA (Optional) Want to track the same user across their laptop, phone, and tablet? Google Analytics supports User ID tracking - it identifies logged-in users across different devices or sessions. :::note[User ID in GA4] GA4 handles user identification differently than older versions. When Tallyfy sends user data, GA4 automatically associates events with the user across devices. Go to **Admin** > **Reporting identity** to configure how GA4 identifies users (blended, observed, or device-based). ::: :::note[Data takes time] Google Analytics typically takes 24-48 hours to process and display new data. Don't panic if you don't see anything right away. ::: ## Setting up Mixpanel Integration Mixpanel is another analytics tool you can connect to Tallyfy. It's great for tracking specific events and user actions. ### How to connect Mixpanel ### What Mixpanel tracks Mixpanel captures detailed information about specific actions people take in Tallyfy: - Viewing a template - Completing a step - Launching a process - Engaging with specific documents ![Mixpanel analytics showing blueprint viewed events](https://screenshots.tallyfy.com/tallyfy/pro/analytics-blueprint-viewed-events.png) :::caution[Privacy with Mixpanel] Mixpanel collects detailed event data in your Mixpanel account - including user information. Make sure your company's privacy policy covers this data collection. ::: ### Using the Analytics Data Once you're connected, here's what you can do with Google Analytics or Mixpanel: - Build custom reports about Tallyfy usage - Create real-time dashboards to spot trends - Set up alerts when usage patterns change - Export data for deeper analysis Need help with specific reporting? Contact Tallyfy support. [^1]: Unlimited free external users who access Tallyfy via special guest_code authentication [^2]: GA4 feature that captures additional event parameters beyond standard metrics; required for Tallyfy-specific tracking - **[Why use BI platforms vs. native analytics?](https://tallyfy.com/products/pro/integrations/analytics/why-use-a-dedicated-bi-platform-with-tallyfy/)**: Tallyfy connects to external BI platforms like Power BI and Tableau rather than building native analytics because specialized tools offer superior visualization capabilities and advanced features while enabling cross-platform data integration and maintaining flexibility without vendor lock-in. ## Business Intelligence Integration Strategy Tallyfy integrates with existing Business Intelligence (BI) platforms rather than building a limited native analytics solution. Why? Because this approach gives organizations real advantages when analyzing their workflow data. ### Using specialized analytics tools Instead of reinventing the wheel, Tallyfy connects directly with industry-leading BI platforms. Here's what you get: - **Purpose-built functionality** - Dedicated BI tools deliver powerful visualization capabilities - **Advanced analytics features** - Access to statistical analysis, predictive modeling, and AI insights - **Continual innovation** - Benefit from ongoing development by BI platform specialists - **Familiar interfaces** - Your teams can use tools they already know ### Cross-Platform Data Integration Want to see the bigger picture? External BI integration lets you combine Tallyfy data with information from other business systems: - Merge workflow performance with financial metrics - Connect process efficiency to customer satisfaction data - Integrate task completion rates with resource utilization - Combine multiple data sources for complete operational insights ### Platform Independence and Flexibility You're not stuck with one solution. Tallyfy's analytics approach keeps you flexible: - **Platform choice** - Pick the BI solution that fits your organization best - **No vendor lock-in** - Switch analytics tools without losing access to your process data - **Customization options** - Build dashboards and reports tailored to specific roles - **Scalability** - Grow your analytics capabilities without changing your workflow platform ### Data Portability for Future Innovation Your workflow data isn't trapped - it's ready for whatever comes next: - **Data science accessibility** - Give data scientists direct access to raw process data - **Machine learning readiness** - Train AI models on your workflow patterns and outcomes - **Open data formats** - Standard CSV and SQL interfaces ensure future compatibility - **Data ownership** - You maintain full control of your organizational data assets ### Resource Optimization Here's the thing - you've already invested in analytics tools and talent. Use them: - Use your current BI platform licenses - Put your existing data analysts and BI specialists to work - Avoid duplicating analytics infrastructure - Focus on insights, not learning new tools This integration approach gets you the best of both worlds - Tallyfy's workflow management plus the analytics power of specialized BI platforms. ## Why Tallyfy connects to BI tools instead of building its own reports We made a choice. Instead of building basic reporting features inside Tallyfy, we focus on making it easy to connect your process data to powerful BI tools your company might already use - like Power BI, Tableau, or Looker. Here's why this approach works better: ### Use the best tools for the job BI platforms are built for one thing - data analysis. They offer way more than we could ever build internally: - **Better charts and graphs**: BI tools excel at creating effective data visualizations - **Advanced features**: Get deeper analysis, predictions, and AI-powered insights - **Constant improvement**: BI companies update their tools with new features all the time - **Familiar tools**: Your team can use the reporting tools they already know ### Combine Tallyfy data with other business data External BI tools let you mix Tallyfy data with information from other systems. The result? You see the complete picture: - Track how process efficiency affects financial results - Link workflow times to customer satisfaction scores (but remember: workflow times show elapsed time, not effort - see [tracking actual work time](/products/pro/tutorials/how-to/track-time-in-tasks/#analytics-timestamps-inherit-these-challenges)) - Compare task completion rates with employee schedules or costs - Combine data from sales, support, and operations ### Freedom and flexibility You get choices. Lots of them: - **Choose your favorite BI tool**: Pick the platform that works best for your company - **Avoid being locked in**: Switch BI tools later? You can still access your Tallyfy data - **Customize reports**: Build the exact dashboards and reports different teams need - **Grow easily**: Your reporting capabilities can expand without touching Tallyfy ### Your data is ready for the future Raw process data, available separately. What does that mean for you? - **Data scientists can use it**: Your data team gets easy access for deep analysis - **Ready for AI/Machine Learning**: Train predictive models on your workflow history - **Standard formats**: SQL access ensures compatibility with future tools - **You own your data**: You always keep full control over your company's process data ### Use your existing resources Stop reinventing. Start using what you have: - Use existing licenses for Power BI, Tableau, and other tools - Your current data analysts already know these platforms - Skip paying for (and learning) separate reporting systems - Focus on insights, not new tool training That's the power of integration. Tallyfy handles workflow management while best-in-class BI tools handle your analytics. - **[Looker](https://tallyfy.com/products/pro/integrations/analytics/looker/)**: Looker integrates with Tallyfy Analytics through Amazon Athena to transform workflow data into interactive dashboards and embedded analytics that enable teams to explore process insights answer business questions and monitor performance in real-time without requiring technical expertise. ## Looker Integration with Tallyfy Analytics Want to turn workflow data into interactive insights your whole team can explore? Looker connects directly to Tallyfy Analytics, transforming raw process information into dashboards that answer questions you didn't even know you had. :::note[Looker vs Looker Studio] This guide covers both **Looker** (Google Cloud's enterprise BI platform) and **Looker Studio** (free visualization tool, formerly Google Data Studio). Both integrate with Tallyfy Analytics through Amazon Athena, but use different connection methods. Choose the one that matches your needs and budget. ::: ### Integration Benefits - **Interactive Data Exploration** - Click, filter, and drill down through your workflow data without writing queries - **Embedded Analytics** - Share live dashboards with stakeholders who don't need full BI tool access - **Real-time Monitoring** - Watch processes unfold with dashboards that update as work happens - **Collaborative Intelligence** - Build once, share everywhere - from Slack to email to web portals - **Self-Service Analytics** - Empower team members to answer their own questions without IT bottlenecks ### Key Capabilities | Feature | Description | |---------|-------------| | Live Connectivity | Direct connection to Tallyfy data via Amazon Athena[^1] | | LookML Modeling | Define relationships and calculations once, use everywhere | | Embedded Dashboards | Integrate analytics into your existing applications | | Scheduled Delivery | Email reports automatically on your schedule | | Mobile Access | Access insights from any device, anywhere | ### Business Applications Here's what you can actually build with Looker and Tallyfy together: 1. **Executive Dashboards** - Give leadership the 10,000-foot view with drill-down into details 2. **Process Performance Monitoring** - Spot bottlenecks before they become problems 3. **Team Analytics** - See who's crushing their tasks and who needs support 4. **Customer Journey Analysis** - Track how form submissions flow through your processes 5. **Compliance Reporting** - Prove you're meeting SLAs with timestamp evidence 6. **Workload Distribution** - Balance assignments across your team based on real data ### Technical Architecture The connection works through a straightforward chain: - **Tallyfy Analytics** - Your process data stored securely in Amazon S3 - **Amazon Athena** - Query engine that runs SQL on your data lake - **Simba JDBC Driver** - The bridge connecting Looker to Athena - **Looker Platform** - Where you build models and create visualizations - **Looker API** - Embed dashboards anywhere you need them ### Authentication Requirements When Tallyfy provisions your Analytics account, you'll receive two credential sets. Keep them straight: - **AWS IAM Login** (username/password) - For AWS web console access only - **Access Key and Secret Access Key** - Your credentials for Looker connections :::note[Important] Looker needs the Access Key and Secret Access Key - not the IAM username/password. Token-based authentication works better with BI platforms and avoids those frustrating "security token invalid" errors. ::: ### Performance Optimization Looker offers some neat tricks for working with Athena data: - **Result Streaming** - Large result sets? Enable streaming to improve extraction speed - **Persistent Derived Tables** - Cache complex calculations in S3 for faster dashboard loading - **Connection Pooling** - Increase concurrent connections if Looker is your primary analytics tool - **Query Optimization** - Use Looker's aggregate awareness to pre-calculate common metrics :::tip[Understanding time metrics] Task duration metrics in Looker show elapsed time between assignment and completion - not actual working time. These timestamps include holidays, multi-tasking periods, and external delays. For accurate effort tracking, see [how to track time spent on tasks](/products/pro/tutorials/how-to/track-time-in-tasks/#analytics-timestamps-inherit-these-challenges). ::: ### Getting Started Ready to connect? Here's your roadmap: **For Looker (Enterprise Platform):** 1. Make sure you've got an active Tallyfy Analytics subscription 2. Verify you have Looker access (self-hosted or Looker Cloud) 3. Gather your Access Key and Secret Access Key from Tallyfy 4. Follow the Looker connection guide to set everything up 5. Start exploring your data - Looker makes it surprisingly intuitive **For Looker Studio (Free Tool):** 1. Ensure you have an active Tallyfy Analytics subscription 2. Sign up for a free Looker Studio account 3. Choose a third-party connector (CData or OWOX) 4. Configure the connector with your Athena credentials 5. Start building reports and visualizations Setup takes about 15-20 minutes for Looker, or 10-15 minutes for Looker Studio. The detailed connection guides below walk you through each option. [^1]: AWS serverless query service using standard SQL on S3 data lakes, no infrastructure management needed - **[Sigma Computing](https://tallyfy.com/products/pro/integrations/analytics/sigma/)**: Sigma Computing is a cloud-native analytics platform that provides spreadsheet-like data exploration capabilities but currently does not support direct connections to AWS Athena which powers Tallyfy Analytics. ## Sigma Computing Overview Sigma Computing is a cloud-native BI platform that feels like using a spreadsheet - but with the power of cloud data warehouses behind it. Here's the catch: it can't connect directly to AWS Athena, which powers Tallyfy Analytics. ### About Sigma Computing Sigma lets business users explore data without writing a single line of SQL. If you're comfortable with Excel, you'll feel right at home. The platform focuses on: - **Familiar Interface** - Spreadsheet-like experience for data exploration - **Cloud-Native Architecture** - Built specifically for cloud data platforms - **Self-Service Analytics** - Empowers business users to create their own analyses - **Live Data Connections** - Real-time queries without data extraction - **Collaborative Features** - Team-based workbook editing and sharing ### Current Connection Limitations **Important Note**: Sigma Computing does not currently support connections to AWS Athena, which is the query engine that powers Tallyfy Analytics. Sigma Computing connects directly to these data warehouse platforms: | Supported Platforms | Connection Type | |-------------------|-----------------| | Snowflake | Native connector | | Google BigQuery | Native connector | | Amazon Redshift | Native connector | | Databricks | Native connector | | PostgreSQL | Native connector | | MySQL | Native connector | | Microsoft SQL Server | Native connector | | AlloyDB | Native connector | | Starburst | Native connector | ### Why Sigma Doesn't Support Athena Sigma needs persistent connections to data warehouses - think of it like keeping a phone line open. AWS Athena works differently. It's serverless, which means: - **Serverless Architecture** - Athena doesn't maintain persistent connections - **Query-on-Demand** - Different connection patterns than traditional warehouses - **S3-Based Storage** - Data stored in S3 rather than warehouse tables ### Potential Workarounds Can't connect directly? You've got options: #### Option 1: Use Redshift Spectrum Got Amazon Redshift? Use Redshift Spectrum to query your S3 data (that's where Tallyfy Analytics stores everything). Then connect Sigma to Redshift. Problem solved. #### Option 2: Data Warehouse Migration Move your analytics data to a warehouse Sigma actually supports: - **Snowflake** - The go-to for most teams running analytics - **BigQuery** - Google's serverless option (yes, serverless but still works) - **Redshift** - Amazon's tried-and-true warehouse #### Option 3: Alternative BI Tools Want to stick with Athena? These tools play nice with it: - Power BI (just install the right drivers) - Tableau (works great with JDBC) - AWS QuickSight (built for Athena - no surprises there) ### Future Considerations Things change fast in the data world. Here's what you can do: - **Monitor Sigma's Roadmap** - They might add Athena support eventually - **Submit Feature Requests** - Tell Sigma you need this (the squeaky wheel gets the grease) - **Evaluate Architectural Changes** - Maybe it's time to rethink your data stack anyway? ### Getting Started with Sigma If you decide to go with Sigma (and a compatible warehouse), they'll give you: - Free trials to test things out - Tons of documentation and training - Professional help if you need it - An active community But let's be honest - if you're using Tallyfy Analytics right now, stick with Power BI or Tableau. They work perfectly with Athena. - **[Tableau](https://tallyfy.com/products/pro/integrations/analytics/tableau/)**: Tableau connects directly to Tallyfy Analytics through Amazon Athena to transform raw workflow data into interactive visualizations and dashboards that reveal process patterns and enable data-driven optimization across teams. ## Tableau Integration with Tallyfy Analytics Want to turn your workflow data into stunning visualizations? Tableau connects directly to Tallyfy Analytics, transforming raw process data into interactive dashboards that actually make sense. No more squinting at spreadsheets. ### Integration Benefits - **Visual Process Analysis** - Create visualizations that reveal workflow patterns you'd never spot in raw data - **Interactive Dashboards** - Build reports that respond to clicks - filter, drill down, and explore on the fly - **Data-Driven Optimization** - Finally see where tasks get stuck (and why) - **Multiple Visualization Options** - Charts, heatmaps, scatter plots - pick what works for your data - **Self-Service Analytics** - Let team members answer their own questions without IT help ### Key Capabilities | Feature | Description | |---------|-------------| | Live Connectivity | Direct connection to Tallyfy data via Amazon Athena | | Visual Interface | Create visualizations without coding knowledge | | Calculation Engine | Apply formulas and transformations to workflow data | | Publishing Options | Share dashboards with team members and stakeholders | | Scheduled Refreshes | Automate data updates for regular reporting | ### Business Applications Here's what you can actually do with Tableau and Tallyfy together: 1. **Monitor Process Efficiency** - Track completion times and identify improvement opportunities 2. **Analyze Team Performance** - Discover who's crushing it and who needs support 3. **Evaluate Form Data** - Turn form responses into trends and insights 4. **Track SLA Compliance** - Know instantly if you're meeting your 24-hour response times 5. **Create Executive Dashboards** - Give leadership the 30,000-foot view they crave ### Technical Architecture The integration works through a simple chain: - **Tallyfy Analytics** - Your process data lives securely in Amazon S3 - **Amazon Athena** - Query that data with standard SQL (yes, it's that straightforward) - **JDBC Driver** - The bridge connecting Tableau to Athena - **Tableau Desktop** - Where you build those eye-catching visualizations - **Tableau Server/Online** (optional) - Share dashboards company-wide ### Getting Started Ready to dive in? Here's your roadmap: 1. Make sure you've got Tallyfy Analytics activated (takes 10 minutes) 2. Download and install Tableau Desktop 3. Connect to your data - the setup guide walks you through each click 4. Start dragging and dropping to create your first visualization 5. Share the "aha!" moments with your team Need specifics? The articles below cover everything from initial connection to troubleshooting those pesky error messages. - **[Power BI](https://tallyfy.com/products/pro/integrations/analytics/powerbi/)**: Power BI integration transforms Tallyfy workflow data into interactive visualizations and actionable insights through Amazon Athena connectivity enabling process optimization team performance analysis and executive reporting with real-time data access and customizable dashboards. ## Power BI Integration Overview Power BI transforms your Tallyfy data into stunning visualizations and actionable insights. Want to see exactly how your workflows perform? This integration makes it happen - connecting Microsoft's business intelligence powerhouse directly to your process data through customized dashboards and reports. ### Key Capabilities - **Interactive Dashboards** - Create dynamic visualizations that respond to member or guest interactions - **Process Performance Analysis** - Measure and optimize workflow efficiency with detailed metrics - **Custom Report Development** - Design tailored reports for different stakeholders and needs - **Real-time Data Access** - Connect directly to your live process data through Amazon Athena[^1] - **Cross-data Analysis** - Combine Tallyfy data with information from other business systems ### How the Integration Works Here's the magic: Tallyfy Analytics stores your process data in Amazon Athena - think of it as a super-fast query engine that never sleeps. Power BI then connects through ODBC drivers[^2] (yes, those trusty connectors), letting you build visualizations based on: 1. Process completion times and volumes 2. Task assignments and performance metrics 3. Form field data collected during processes 4. Member and guest engagement and participation statistics ### Common Use Cases | Business Need | Power BI Solution | |---------------|-------------------| | Process Optimization | Duration analysis dashboards highlighting bottlenecks | | Team Performance | Member or guest activity reports showing completion metrics | | Data Collection | Visualization of form field data across processes | | Executive Reporting | High-level KPI dashboards with drill-down capabilities | | Compliance Tracking | Audit trails and documentation of process compliance | :::tip[Understanding time metrics] Task duration metrics in Power BI show elapsed time between assignment and completion - not actual working time. These timestamps include holidays, multi-tasking periods, and external delays. For accurate effort tracking, see [how to track time spent on tasks](/products/pro/tutorials/how-to/track-time-in-tasks/#analytics-timestamps-inherit-these-challenges). ::: ### Authentication Requirements You'll get two sets of credentials when Tallyfy Analytics is provisioned. Keep them straight: - **AWS IAM Login** (username/password) - This one's just for the AWS web console - **Access Key and Secret Access Key** - These are your golden tickets for Power BI connections :::note[Important] Power BI needs the Access Key and Secret Access Key - not the IAM credentials. Why? Token-based authentication simply works better with analytics tools. Trust us on this one. ::: ### Getting Started Ready to dive in? Here's your roadmap: 1. Make sure you've got an active Tallyfy Analytics subscription 2. Download and install Power BI Desktop (it's free) 3. Grab your Access Key and Secret Access Key from Tallyfy 4. Follow the connection guide to link everything up 5. Start creating those eye-catching visualizations Takes about 15 minutes to set up. The detailed connection guide below walks you through each step. [^1]: AWS serverless query service using standard SQL on S3 data lakes, no infrastructure management needed [^2]: Open Database Connectivity standard that enables apps to access various databases using SQL ### Looker - **[Connecting Looker Studio to analytics data](https://tallyfy.com/products/pro/integrations/analytics/looker/how-to-connect-looker-studio-to-tallyfy-data/)**: Looker Studio connects to Tallyfy Analytics data in 10-15 minutes using third-party connectors like CData Connect Cloud or OWOX BI since native Amazon Athena support isn't available and the setup requires configuring Access Key authentication credentials provided by Tallyfy Support to enable free shareable dashboard creation from workflow process step form field and user data tables. ## Connect Looker Studio to Tallyfy data You can connect Looker Studio to Tallyfy in about 10-15 minutes using a third-party connector. Once connected, you'll create free, shareable dashboards and reports from your workflow data without paying for an enterprise BI platform. :::note[Looker Studio vs Looker] This guide covers **Looker Studio** (the free visualization tool). Looking for **Looker** (Google Cloud's enterprise BI platform)? Check out the [Looker connection guide](/products/pro/integrations/analytics/looker/how-to-connect-looker-to-tallyfy-data/) instead. ::: ### Requirements Before you start, make sure you have: - Tallyfy Analytics subscription activated for your organization - Free Looker Studio account (sign up at [lookerstudio.google.com](https://lookerstudio.google.com)) - Authentication credentials provided by Tallyfy Support - Third-party connector subscription (CData or OWOX) :::caution[No Native Athena Support] Unlike the enterprise Looker platform, Looker Studio doesn't have built-in Amazon Athena connectivity. You'll need a third-party connector to bridge the gap. The good news? Setup is still quick and straightforward. ::: ## Authentication Overview Amazon Athena (which hosts Tallyfy Analytics data) offers two authentication methods: | Method | Description | Best For | |--------|-------------|----------| | IAM Username/Password | Web console access credentials | AWS Console access only | | Access Key/Secret | Token-based authentication | Connector authentication (recommended) | :::caution[Important Note] When Tallyfy provisions your Analytics account, you'll receive two distinct credential sets: - **AWS IAM login** - Use only for accessing the AWS web console - **Access Key + Secret Access Key** - Use for connecting Looker Studio connectors ::: ## Connector Options Two reliable connectors support Athena-to-Looker Studio integration: ### Option 1: CData Connect Cloud **Best For**: Organizations needing reliable data connectivity with minimal setup - **Pricing**: Subscription-based (check [CData pricing](https://www.cdata.com/pricing/)) - **Setup Time**: 10-15 minutes - **Features**: Direct cloud-to-cloud connectivity, automatic query optimization, no data replication - **Support**: Enterprise-grade technical support ### Option 2: OWOX BI Connector **Best For**: Marketing teams already using OWOX for analytics - **Pricing**: Free (check [OWOX connector page](https://www.owox.com/products/athena-to-looker-studio-connector)) - **Setup Time**: 10-15 minutes - **Features**: Direct AWS integration, no intermediate processing steps - **Support**: Email and documentation support :::tip[Choosing a Connector] Both connectors work well with Tallyfy Analytics. Choose CData if you need broader data connectivity options beyond Athena. Choose OWOX if you're already in their ecosystem for marketing analytics. ::: ## Setup Process with CData Connect Cloud ### Step 1: Configure CData Connection ### Step 2: Connect Looker Studio to CData ### Step 3: Build Your First Report ## Setup Process with OWOX Connector ### Step 1: Configure OWOX Connection ### Step 2: Connect Looker Studio to OWOX ## Working with Tallyfy Data in Looker Studio ### Available Data Tables Tallyfy Analytics provides four main tables: - **processes** - Completed and in-progress workflow instances with start/end times - **steps** - Individual task data within processes including assignments and durations - **form_fields** - Form field values collected during workflows - **users** - User activity and participation metrics across all processes ### Creating Effective Visualizations What can you actually build? Here are popular dashboards our customers create: 1. **Process Volume Trends** - Line charts showing processes launched over time 2. **Completion Rate Scorecards** - Big numbers showing percentage of on-time completions 3. **Task Duration Heatmaps** - Identify bottlenecks by visualizing average task durations 4. **User Activity Tables** - Leaderboards showing top performers by completion rate 5. **Form Response Analysis** - Pivot tables and charts exploring form field data patterns :::caution[Interpreting time metrics] Duration and handling time metrics show elapsed calendar time between task assignment and completion. This includes weekends, holidays, and waiting periods. For actual effort tracking, see [how to track time spent on tasks](/products/pro/tutorials/how-to/track-time-in-tasks/#analytics-timestamps-inherit-these-challenges). ::: ## Performance Tips Make your Looker Studio reports faster: - **Use Date Range Controls** - Don't pull all historical data every time - **Apply Filters Early** - Filter at the data source level, not in charts - **Limit Table Rows** - Show top 10 or 20, not thousands of rows - **Cache Reports** - Enable data freshness caching (reports update every 12-24 hours) - **Optimize Queries** - Pre-aggregate data in Athena views when possible :::tip[Data Freshness] Looker Studio caches data to improve performance. If you need real-time data, adjust the data freshness setting in your data source configuration. For most workflow analytics, daily updates work perfectly fine. ::: ## Sharing and Collaboration One of Looker Studio's best features? Sharing is dead simple: - **View Access** - Share report URLs with anyone who needs to see insights - **Edit Access** - Let team members modify reports and create new visualizations - **Embed Reports** - Drop reports into websites or internal portals with iframe embeds - **Schedule Emails** - Auto-send report snapshots on your preferred schedule - **Mobile Friendly** - All reports work great on phones and tablets ## Troubleshooting Connection Issues Connection not working? Let's fix it. Check these things in order: - **Verify Credentials** - Double-check your Access Key and Secret Access Key (even one wrong character breaks everything) - **Check Permissions** - Ensure your credentials have `AmazonAthenaFullAccess` and `AmazonS3FullAccess` policies attached - **Validate S3 Path** - Confirm your S3 staging directory path is exactly as provided by Tallyfy - **Test in AWS Console** - Try running a query in the Athena web console to rule out credential issues - **Check Connector Status** - Verify your CData or OWOX subscription is active - **Review Region Settings** - Ensure you're using the correct AWS region (typically `us-east-1`) Still stuck? Contact your connector provider's support team first (they'll diagnose connection issues), then reach out to Tallyfy Support if the issue appears to be with your Analytics account. ## Cost Considerations Let's talk money - what does this setup actually cost? | Component | Cost | Notes | |-----------|------|-------| | Looker Studio | **Free** | Unlimited reports and dashboards | | Tallyfy Analytics | Subscription | Contact Tallyfy for pricing | | CData Connect Cloud | Subscription | Starts around $49/month | | OWOX Connector | **Free** | Free Athena connector | | AWS Query Costs | Pay-per-query | Varies based on data scanned | :::tip[Optimizing AWS Costs] Athena charges based on data scanned. Reduce costs by: - Using date range filters in reports - Partitioning data by date (Tallyfy does this automatically) - Caching report data in Looker Studio - Limiting the number of columns you query ::: ## Comparison: Looker Studio vs Enterprise Looker Not sure which option fits your needs? Here's the breakdown: | Feature | Looker Studio | Enterprise Looker | |---------|---------------|-------------------| | **Cost** | Free + connector fee | Subscription-based | | **Setup Complexity** | Simple (10-15 min) | Moderate (15-20 min) | | **Data Modeling** | Basic | Advanced (LookML) | | **Embedded Analytics** | iframe embeds | Full API | | **Collaboration** | Share links | Role-based access | | **Best For** | Small teams, basic dashboards | Large teams, complex analytics | - **[Connecting Looker to analytics data](https://tallyfy.com/products/pro/integrations/analytics/looker/how-to-connect-looker-to-tallyfy-data/)**: This guide demonstrates how to connect Looker to Tallyfy workflow data through Amazon Athena in 15-20 minutes using Access Key authentication driver installation connection configuration and LookML modeling to create interactive dashboards and visualizations from processes steps form fields and user data. ## Connect Looker to Tallyfy data You can connect Looker (the enterprise BI platform) to Tallyfy in about 15-20 minutes using Amazon Athena. Once connected, you'll build LookML models and interactive dashboards that make your workflow data actually useful. :::note[Looker vs Looker Studio] This guide covers **Looker** (Google Cloud's enterprise BI platform). Looking for **Looker Studio** (the free visualization tool)? Check out the [Looker Studio connection guide](/products/pro/integrations/analytics/looker/how-to-connect-looker-studio-to-tallyfy-data/) instead. ::: ### Requirements Before you start, make sure you have these five things: - Tallyfy Analytics subscription activated for your organization - Looker access (self-hosted or Looker Cloud) - Administrative permissions in Looker to create database connections - Administrative access to your computer for driver installation (if self-hosted) - Authentication credentials provided by Tallyfy Support ## Authentication Overview Amazon Athena (which hosts Tallyfy Analytics data) offers two authentication methods: | Method | Description | Best For | |--------|-------------|----------| | IAM Username/Password | Web console access credentials | AWS Console access only | | Access Key/Secret | Token-based authentication | BI tool connections (recommended) | :::caution[Important Note] When Tallyfy provisions your Analytics account, you'll receive two distinct credential sets: - **AWS IAM login** - Use only for accessing the AWS web console - **Access Key + Secret Access Key** - Use for connecting Looker and other BI tools ::: Why does this matter? Token-based authentication (Access Key + Secret Access Key) gives you reliable connections without those frustrating "security token invalid" errors. Trust me - use the Access Keys for Looker. ## Setup Process ### Step 1: Install Required Drivers (Self-Hosted Looker Only) If you're using Looker Cloud, skip this step - Google handles the drivers. For self-hosted Looker instances: :::note[Driver Versions] AWS maintains two JDBC driver versions (2.x and 3.x). The 3.x driver offers better performance, especially for large result sets. Grab the latest 3.x version unless you have specific compatibility requirements. ::: ### Step 2: Configure Looker Connection ![](https://screenshots.tallyfy.com/looker-athena-connection.png) :::tip[S3 Staging Directory] The S3 staging directory is where Athena stores query results. Tallyfy Support provides this path when they provision your Analytics account. Make sure your Access Key has write permissions to this bucket. ::: ### Step 3: Configure Performance Settings Want faster queries? Here's how to optimize: :::note[Connection Pooling] The default is 5 concurrent connections. If Looker is your primary analytics tool for Tallyfy data, bump this to 10-20. If you're just doing occasional exploration, leave it at 5 to conserve resources. ::: ### Step 4: Set Up Temp Database for PDTs Persistent Derived Tables (PDTs) cache complex calculations for faster dashboard loading: ## Working with Tallyfy Data in Looker ### Available Data Tables Tallyfy Analytics gives you access to four main tables: - **processes** - Completed and in-progress workflow instances - **steps** - Individual task data within processes - **form_fields** - Form field values collected during workflows - **users** - User activity and participation metrics ### Building Your First LookML Model Ready to start modeling? Here's a basic example: ### Creating Effective Visualizations What can you actually build? Here are the most popular dashboards: 1. **Process Duration Analysis** - See where workflows get stuck (remember: durations show elapsed time, not effort) 2. **Team Performance Scorecards** - Track completion rates and average handling times per user 3. **Form Data Analytics** - Spot trends in customer requests or quality issues 4. **Real-time Process Monitors** - Dashboard showing active processes and their current status 5. **SLA Compliance Tracking** - Measure whether tasks complete within target timeframes :::caution[Interpreting time metrics] Duration and handling time metrics show elapsed calendar time between task assignment and completion. This includes weekends, holidays, and waiting periods. For actual effort tracking, see [how to track time spent on tasks](/products/pro/tutorials/how-to/track-time-in-tasks/#analytics-timestamps-inherit-these-challenges). ::: ## Advanced Features ### Embedding Looker Dashboards Want to share insights beyond Looker? Use the Looker API to embed dashboards: - Embed in internal portals or wikis - Share via Slack using Looker's Slack integration - Schedule email delivery of reports - Create public dashboards with controlled access ### Query Optimization Tips Make your queries blazing fast: - **Use Aggregate Awareness** - Pre-calculate common metrics in PDTs - **Use Incremental PDTs** - Only recalculate changed data - **Apply Smart Filters** - Push filtering to Athena rather than post-processing in Looker - **Monitor Query Performance** - Use Looker's Query History to identify slow queries ## Troubleshooting Connection Issues Connection not working? Let's fix it. Check these things in order: - Double-check your Access Key and Secret Access Key - even one wrong character breaks everything - Verify the S3 staging directory path is correct and your credentials have write access - Make sure the JDBC driver is installed correctly (self-hosted only) - Test if your Looker instance can reach `athena.us-east-1.amazonaws.com` on port 443 - Verify your Tallyfy Analytics subscription is active in your account settings - Check driver logs by adding `;LogLevel=DEBUG;LogPath=/tmp/athena_debug.log` to Additional Params Still stuck? Contact Tallyfy Support with the exact error message you're seeing. ## Debugging Tips Enable detailed logging to diagnose issues: 1. Add to **Additional Params**: `;LogLevel=DEBUG;LogPath=/tmp/athena_debug.log` 2. Attempt your connection 3. Check `/tmp/athena_debug.log` for detailed error information 4. Share relevant log excerpts with Tallyfy Support if needed ### Sigma - **[Alternatives for spreadsheet-style analytics](https://tallyfy.com/products/pro/integrations/analytics/sigma/alternatives-for-tallyfy-analytics/)**: This guide explores alternative analytics solutions for teams seeking Sigma Computing's spreadsheet-style data exploration with Tallyfy Analytics and recommends Power BI as the closest match while also covering Tableau and AWS QuickSight options along with implementation strategies for hybrid Excel approaches and custom self-service portals. ## Finding Sigma-Like Functionality for Tallyfy Analytics Sigma Computing can't connect directly to Tallyfy Analytics - but don't worry. Several alternatives offer that same spreadsheet-style data exploration you're after. Let's find the best fit for your team. ### What Makes Sigma Unique Here's what Sigma does differently (and what we need to replicate): - **Spreadsheet Interface** - Familiar Excel-like interaction model - **Self-Service Analytics** - Business users can explore data on their own - **Live Data Connections** - Real-time queries without data downloads - **Collaborative Editing** - Team-based workbook creation and sharing - **No-Code Data Manipulation** - Point-and-click data transformation - **Cloud-Native Performance** - Built for modern data warehouses ## Top Alternative Solutions ### Option 1: Power BI with Excel Integration Power BI gets you closest to Sigma's spreadsheet experience. Better yet, it works perfectly with Tallyfy Analytics. #### Benefits for Sigma Users - **Familiar Interface** - Excel-like grid views and data manipulation - **Self-Service Capabilities** - Business user-friendly data exploration - **Direct Athena Connection** - Native connectivity to Tallyfy Analytics - **Microsoft Ecosystem** - Works with familiar Office tools - **Collaborative Features** - Workbook sharing and team editing #### Implementation Approach **Best For:** Organizations already using Microsoft tools or wanting the closest Sigma alternative. ### Option 2: Tableau with Data Source Filters Tableau brings powerful analytics to the table. You'll get some spreadsheet features - though it's more visualization-focused. #### Spreadsheet-Style Features - **Data Grid Views** - Table-based data exploration - **Drag-and-Drop Interface** - Intuitive data manipulation - **Live Connections** - Real-time Athena querying - **Calculated Fields** - Formula-based data transformation - **Collaborative Dashboards** - Team-based content creation #### Key Differences from Sigma - More visualization-focused than spreadsheet-focused - Steeper learning curve for business users - Better advanced analytics capabilities - Enterprise-grade governance features **Best For:** Organizations that need advanced visualization capabilities alongside spreadsheet-style exploration. ### Option 3: AWS QuickSight with Parameterized Dashboards If you're already in AWS, QuickSight makes sense. Native integration and growing self-service features sweeten the deal. #### Sigma-Like Features - **SPICE In-Memory** - Fast, spreadsheet-like performance - **Auto-Generated Insights** - AI-powered data discovery - **Self-Service Exploration** - Business user-friendly interface - **Native Athena Integration** - Direct Tallyfy Analytics connectivity - **Collaborative Dashboards** - Team-based analytics #### Implementation Benefits - **Streamlined Setup** - No additional driver configuration needed - **No Driver Setup** - Native Athena connectivity - **AWS Ecosystem** - Built-in security and management - **Serverless Scaling** - Matches Athena's serverless setup **Best For:** AWS-focused organizations that want direct native integration. ## Implementation Strategies ### Strategy 1: Hybrid Approach with Excel Want maximum user adoption? Combine Excel's familiar interface with Power BI's connectivity. It works. #### Setup Process 1. **Power BI as Data Gateway** - Use Power BI to connect to Tallyfy Analytics 2. **Excel Integration** - Send data to Excel for detailed manipulation 3. **Automated Refresh** - Schedule regular data updates 4. **Dashboard Creation** - Build summary dashboards in Power BI 5. **User Training** - Focus on Excel-familiar workflows #### Benefits - Uses existing Excel skills - Minimal learning curve for business users - Combines spreadsheet flexibility with BI power - Leverages existing Microsoft licensing ### Strategy 2: Data Warehouse Modernization Really want the full Sigma experience? You'll need to switch warehouses. Here are your options. #### Recommended Warehouses **Snowflake** - Excellent Sigma integration - Advanced analytics capabilities - Automatic scaling and optimization - Handles large datasets with ease **Amazon Redshift** - Native AWS integration - Use Redshift Spectrum for S3 data access - Familiar SQL interface - Works with existing AWS infrastructure #### Migration Considerations - **Data Pipeline Setup** - Sync from S3 to chosen warehouse - **Cost Analysis** - Compare warehouse costs vs current Athena usage - **Performance Testing** - Check query performance improvements - **User Training** - Get teams ready for new platform ### Strategy 3: Custom Self-Service Portal Got development resources? Build your own Sigma-like interface over Athena. #### Technical Architecture 1. **Web-Based Interface** - React/Angular frontend with grid components 2. **Backend API** - Python/Node.js service querying Athena 3. **Authentication** - Works with existing user management 4. **Caching Layer** - Redis/ElastiCache for performance 5. **Export Features** - CSV/Excel download capabilities #### Development Considerations - **Resource Requirements** - Significant development and maintenance effort - **Timeline** - Several months for basic functionality - **Skills Needed** - Full-stack development team - **Ongoing Costs** - Development, hosting, and maintenance ## Choosing the Right Alternative ### Decision Framework | Criteria | Power BI | Tableau | QuickSight | Custom Solution | |----------|----------|---------|------------|-----------------| | **Ease of Use** | High | Medium | Medium | Customizable | | **Spreadsheet Feel** | High | Medium | Low | High | | **Setup Complexity** | Low | Medium | Low | High | | **Advanced Analytics** | Medium | High | Medium | Customizable | | **AWS Integration** | Medium | Medium | High | High | ### Assessment Questions **Budget and Timeline** - What's your budget for BI tooling and setup? - How quickly do you need this running? - Do you have development resources for custom solutions? **User Requirements** - How important is the spreadsheet-like interface? - What's the technical skill level of your main users? - How many users need access to the analytics platform? **Technical Environment** - Are you committed to staying within the AWS ecosystem? - Do you have existing Microsoft or Tableau investments? - What's your appetite for managing extra infrastructure? **Analytics Maturity** - Do you need basic reporting or advanced analytics? - How important are real-time vs. scheduled data updates? - What level of data governance do you require? ## Implementation Recommendations ### For Immediate Needs 1. **Start with Power BI** - Fastest path to Sigma-like functionality 2. **Focus on Key Use Cases** - Set up core reporting requirements first 3. **Plan User Training** - Invest in change management and adoption 4. **Iterate Based on Feedback** - Refine based on user experience ### For Long-Term Strategy 1. **Evaluate Warehouse Migration** - Consider whether Sigma's full capabilities justify the cost 2. **Monitor Sigma Roadmap** - Watch for potential future Athena support 3. **Build Analytics Skills** - Develop internal expertise regardless of tool choice 4. **Plan for Scale** - Ensure your chosen solution supports future growth ### Getting Support - **Vendor Resources** - Use training and support from your chosen vendor - **Community Forums** - Join user communities for tips and best practices - **Professional Services** - Consider implementation consulting for faster deployment - **Internal Champions** - Find power users to drive adoption Pick the right alternative, follow a structured setup approach, and you'll capture most of Sigma's benefits. Your Tallyfy Analytics infrastructure stays intact - and your team gets the spreadsheet-style analytics they need. - **[Connection limitations and alternatives](https://tallyfy.com/products/pro/integrations/analytics/sigma/current-connection-limitations/)**: Sigma Computing cannot directly connect to Tallyfy Analytics due to fundamental architectural incompatibilities between Sigma's need for persistent always-on database connections and AWS Athena's serverless query-by-query model but organizations can work around this limitation using data warehouse bridges like Redshift Spectrum or Snowflake or by switching to alternative BI tools like AWS QuickSight Tableau or Power BI that natively support Athena's serverless architecture. ## Why Sigma Computing Cannot Connect to Tallyfy Analytics Here's the frustrating truth: Sigma Computing can't connect directly to Tallyfy Analytics. It's a powerful BI platform, yes - but the architectural mismatch between Sigma's needs and AWS Athena's serverless design creates an unbridgeable gap. ### Technical Architecture Differences #### Sigma's Connection Model Sigma Computing is designed to work with persistent data warehouse connections that provide: - **Always-On Database Services** - Continuous availability for query processing - **Dedicated Compute Resources** - Consistent processing power allocation - **Standard Database Protocols** - JDBC/ODBC connectivity patterns - **Session Management** - Persistent connections for interactive analysis - **Metadata Catalogs** - Built-in schema and table discovery #### AWS Athena's Serverless Model Tallyfy Analytics uses AWS Athena, which operates on a different paradigm: - **Serverless Query Engine** - No persistent database servers - **On-Demand Processing** - Compute resources allocated per query - **S3-Based Storage** - Data stored as files rather than database tables - **Query-by-Query Billing** - No continuous running costs - **Glue Catalog Integration** - Separate metadata management service ### Specific Connection Challenges #### 1. Connection Persistence Requirements Sigma wants to keep database connections alive throughout your analysis session. But Athena? It spins up connections for each query, then drops them. That's the clash. #### 2. Driver Compatibility Sigma's connectors expect traditional data warehouse JDBC drivers. Athena provides JDBC drivers, sure - but they're built for completely different usage patterns. Square peg, round hole. #### 3. Metadata Discovery When Sigma tries to discover your tables and columns, it looks for standard database metadata APIs. Athena's AWS Glue Data Catalog speaks a different language entirely. #### 4. Query Optimization Sigma optimizes queries assuming you have a traditional database underneath. But Athena's query planning for S3-based data follows entirely different rules. The optimization strategies simply don't translate. ## Alternative Approaches Can't connect directly? Fine. Here are three workarounds that actually work: ### Option 1: Data Warehouse Bridge #### Using Amazon Redshift 1. **Set Up Redshift Cluster** - Create a Redshift cluster in your AWS account 2. **Configure Spectrum** - Use Redshift Spectrum to query S3 data directly 3. **Connect Sigma to Redshift** - Establish connection using Sigma's native Redshift connector 4. **Query Tallyfy Data** - Access your Tallyfy Analytics data through Redshift **Benefits:** - Uses your existing Tallyfy Analytics data storage - No data duplication required - Native Sigma connectivity - Faster query performance for complex analytics **Considerations:** - Additional AWS service costs - Requires Redshift cluster management - Initial Spectrum configuration time #### Using Snowflake 1. **Set Up Snowflake Account** - Create Snowflake warehouse 2. **Configure External Tables** - Set up external tables pointing to your S3 data 3. **Data Pipeline** - Create ETL process to sync data periodically 4. **Connect Sigma** - Use Sigma's native Snowflake connector **Benefits:** - Strong Sigma integration - Advanced analytics capabilities - Automatic scaling and optimization - Handles large datasets efficiently **Considerations:** - Platform licensing costs (usage-based pricing) - Data sync setup and configuration time - Some data latency depending on sync frequency ### Option 2: BI Tool Alternatives Still want to use AWS Athena? These tools actually play nice with it: #### AWS QuickSight - **Native Integration** - Built specifically for AWS services - **Serverless Architecture** - Matches Athena's serverless model - **Direct Connectivity** - No drivers or connectors needed - **Cost-Effective** - Pay-per-use pricing model #### Tableau with JDBC - **Athena JDBC Driver** - Use Amazon's official JDBC driver - **Rich Visualizations** - Advanced charting and dashboard capabilities - **Enterprise Features** - Full sharing and governance - **Proven Integration** - Established connectivity patterns #### Power BI with ODBC - **Microsoft Ecosystem** - Integration with Office and Azure - **Athena Connectivity** - Via ODBC driver configuration - **Self-Service Analytics** - Similar user empowerment to Sigma - **Competitive Pricing** - Cost-effective licensing options ### Option 3: Custom Integration Development Got developers on your team? You could build your own bridge: #### API-Based Approach 1. **Athena API Integration** - Use AWS SDKs to query Athena programmatically 2. **Data Processing Layer** - Transform query results into Sigma-compatible format 3. **Intermediate Storage** - Cache results in Sigma-supported database 4. **Automated Sync** - Schedule regular data updates #### Benefits: - Complete control over data flow - Tailor-made for your specific needs - Real-time updates possible - Add your own business logic #### Considerations: - Significant development investment required - Ongoing maintenance burden - Need AWS and database expertise - Extended timeline to production ## Making the Right Choice ### Evaluate Based on Your Needs | Priority | Recommended Approach | |----------|---------------------| | **Minimal Additional Cost** | Power BI or Tableau with Athena | | **Best Sigma Experience** | Redshift Spectrum or Snowflake | | **AWS Ecosystem Focus** | QuickSight with Athena | | **Custom Requirements** | Custom integration development | | **Quick Implementation** | Tableau or Power BI setup | ### Assessment Questions Ask yourself these questions first: 1. **Budget Constraints** - What additional tool/platform costs are acceptable? 2. **Technical Resources** - Do you have staff to manage additional infrastructure? 3. **Timeline Requirements** - How quickly do you need the solution implemented? 4. **Analytics Complexity** - How sophisticated are your reporting requirements? 5. **User Community** - Who will be primary users of the analytics platform? 6. **Integration Needs** - How important is integration with other business systems? ## Future Possibilities ### Industry Trends Will Sigma ever support Athena? Maybe. The BI industry is slowly catching up to serverless architectures. Watch for these signals: - **Customer Demand Grows** - More organizations adopt serverless analytics - **Technical Challenges Resolve** - New connector architectures emerge - **AWS Partnerships Develop** - Vendors collaborate more closely ### Monitoring Updates Want to know when things change? Keep tabs on: - **Sigma Roadmap** - Check their quarterly product announcements - **AWS Partnerships** - New integrations often debut at re:Invent - **Community Feedback** - Join forums and vote on feature requests - **Technical Documentation** - Both vendors update docs when capabilities change For now? Power BI and Tableau work great with Tallyfy Analytics - check out our guides on setting them up. They're battle-tested and ready to go. ### Tableau - **[Connecting Tableau to analytics data](https://tallyfy.com/products/pro/integrations/analytics/tableau/how-can-i-connect-tableau-to-my-tallyfy-data/)**: You can connect Tableau to Tallyfy Analytics data in about 15 minutes by installing Java and the Amazon Athena JDBC driver then configuring Tableau with your Access Key credentials to access workflow data tables for building dashboards that visualize process durations and user performance metrics. ## Connect Tableau to Tallyfy data You can connect Tableau to Tallyfy in about 15 minutes using Amazon Athena. Once connected, you'll transform your raw workflow data into visual dashboards that actually help you make decisions. Here's the thing - Tallyfy stores your process data in a way that's perfect for business intelligence tools. You just need the right setup. ### Requirements Before you start, make sure you have these four things: - Tallyfy Analytics subscription activated for your organization - Tableau Desktop installed - Administrative access to your computer for driver installation - Authentication credentials provided by Tallyfy Support ## Authentication Overview Amazon Athena (which hosts Tallyfy Analytics data) offers two authentication methods: | Method | Description | Best For | |--------|-------------|----------| | IAM Username/Password | Web console access credentials | AWS Console access only | | Access Key/Secret | Token-based authentication | BI tool connections (recommended) | :::caution[Important Note] When Tallyfy provisions your Analytics account, you'll receive two distinct credential sets: - **AWS IAM login** - Use only for accessing the AWS web console - **Access Key + Secret Access Key** - Use for connecting Tableau and other BI tools ::: Why does this matter? Token-based authentication (Access Key + Secret Access Key) gives you reliable connections without those frustrating "security token invalid" errors. Trust me - use the Access Keys for Tableau. ## Setup Process ### Step 1: Install Required Drivers First things first - you need two drivers installed: :::note[Driver Updates] AWS updates their drivers periodically. Check their documentation for the latest version - it'll save you headaches later. ::: ### Step 2: Configure Tableau Connection ![](https://screenshots.tallyfy.com/tableau-athena-connection.png) ### Step 3: Access Tallyfy Data You're connected! Here's what to do next: ![](https://screenshots.tallyfy.com/tableau-data-selection.png) ## Working with Tallyfy Data in Tableau ### Available Data Tables Tallyfy Analytics gives you access to four main tables: - **processes** - Completed and in-progress workflow instances - **steps** - Individual task data within processes - **form_fields** - Form field values collected during workflows - **users** - User activity and participation metrics ### Creating Effective Visualizations Want to know what you can actually build? Here are the most popular dashboards our customers create: 1. Process duration charts that show exactly where workflows get stuck (remember: durations show elapsed time, not effort) 2. User performance scorecards with task completion rates and average handling times 3. Form data analytics to spot trends in customer requests or quality issues 4. Real-time process monitors showing what's happening right now :::caution[Interpreting time metrics] Duration and handling time metrics show elapsed calendar time between task assignment and completion. This includes weekends, holidays, and waiting periods. For actual effort tracking, see [how to track time spent on tasks](/products/pro/tutorials/how-to/track-time-in-tasks/#analytics-timestamps-inherit-these-challenges). ::: ## Video Tutorial Need a visual walkthrough? This 5-minute video shows the entire setup: ## Troubleshooting Connection Issues Connection not working? Let's fix it. Check these things in order: - Double-check your Access Key and Secret Access Key - even one wrong character breaks everything - Make sure the JDBC driver landed in the right folder (yes, it's picky about location) - Test if your computer can reach athena.us-east-1.amazonaws.com - corporate firewalls sometimes block it - Verify your Tallyfy Analytics subscription is active in your account settings - Restart Tableau after installing drivers (annoying but necessary) Still stuck? Contact Tallyfy Support with the exact error message you're seeing. - **[Troubleshoot issues](https://tallyfy.com/products/pro/integrations/analytics/tableau/how-to-troubleshoot-data-connection-issues-in-tallyfy/)**: This guide addresses common Tableau data connection problems with Tallyfy Analytics by explaining authentication methods troubleshooting steps for missing data sources and preventative measures to maintain reliable dashboard connections. ## Troubleshooting Tableau Data Connection Issues Nothing's more frustrating than a broken data connection right when you need your dashboard. Here's how to fix common Tableau connection problems with Tallyfy Analytics - and prevent them from happening again. ### Authentication Best Practices Amazon Athena (which hosts Tallyfy Analytics data) gives you two ways to authenticate: | Authentication Method | Recommended For | Common Issues | |----------------------|-----------------|---------------| | IAM Username/Password | AWS Console access only | Frequent "security token invalid" errors with BI tools | | Access Key/Secret Key | All BI tool connections | More reliable, fewer token expiration issues | :::caution[Important] Always use the Access Key and Secret Access Key provided by Tallyfy for Tableau connections. IAM credentials (username/password) should only be used for accessing the AWS web console. ::: You'll get two credential sets from Tallyfy when they set up your Analytics account: - **AWS IAM Login** - Use only for AWS console access at https://aws.amazon.com/ - **Access Key and Secret Access Key** - Use for connecting Tableau to Athena ### Common Connection Issues and Solutions #### Issue 1: Authentication Errors That dreaded "The security token included in the request is invalid" error? Here's what to check: #### Issue 2: Missing or Broken Data Source Your workbook's data connection went missing? Don't panic. Follow these steps: #### Issue 3: Connection Cannot Be Edited Sometimes the **Edit Connection** option just won't work. When that happens: ### Data Type Issues After reconnecting, your date fields might look weird. Fix them like this: ### Sharing Workbooks Safely Need to share your masterpiece with colleagues? Keep these security tips in mind: ### Preventative Measures Want to avoid these headaches in the future? Here's what works: - Keep Tableau Desktop and drivers up to date - Use Tableau's **Test Connection** feature regularly - Document your connection settings in a secure location - Create data extracts as backups for critical dashboards - Schedule regular extract refreshes if using Tableau Server/Online Still stuck after trying everything? Contact Tallyfy Support with specific error messages and screenshots - they'll sort you out. - **[Sample Tableau visualizations](https://tallyfy.com/products/pro/integrations/analytics/tableau/sample-tableau-visualizations/)**: Tableau visualization examples demonstrate how to transform Tallyfy Analytics workflow data into actionable business insights through 10 ready-to-use charts and graphs that identify bottlenecks track performance recognize patterns measure compliance and optimize resource distribution across your organization. ## Tableau Visualization Examples for Workflow Analysis Want to see what Tallyfy Analytics data looks like in Tableau? Here are 10 ready-to-use visualizations that answer real business questions about your workflows. ### Visualization Benefits - **Identify Bottlenecks** - Pinpoint where processes slow down - **Track Performance** - Monitor individual and team productivity - **Recognize Patterns** - Discover trends in workflow execution - **Measure Compliance** - Track adherence to deadlines and requirements - **Optimize Resources** - Ensure balanced workload distribution ### Time Performance Visualizations :::tip[Measuring actual work time] These visualizations show elapsed time based on task timestamps. For tracking actual effort time (how long someone actively worked on a task), see [how to track time spent on tasks](/products/pro/tutorials/how-to/track-time-in-tasks/) - this gives you cleaner data that accounts for multi-tasking, holidays, and external delays. ::: #### 1. Task On-Time Completion Rates See at a glance whether your team hits deadlines. This pie chart breaks down tasks into on-time vs. late categories - perfect for quarterly reviews or team meetings. ![](https://screenshots.tallyfy.com/tableau-samples-1.jpg) **Business Questions Answered:** - What percentage of our tasks are completed on schedule? - Is our organization meeting deadline expectations? - Should we reconsider how we establish due dates? #### 2. User Timeliness Comparison This bar chart compares on-time rates across your team. You'll spot your deadline champions - and those who might need a helping hand. ![](https://screenshots.tallyfy.com/tableau-samples-2.jpg) **Business Questions Answered:** - Which team members consistently meet deadlines? - Are there specific users who need assistance with time management? - How do different departments compare in timeliness? #### 3. Timeliness Trend Analysis Watch your team's timeliness trend over weeks or months. Did that new process change help? This chart shows you. ![](https://screenshots.tallyfy.com/tableau-samples-3.jpg) **Business Questions Answered:** - Is our timeliness improving or declining? - Were there specific periods when performance dropped? - Have process changes impacted completion times? ### Workload and Activity Visualizations #### 4. Process Ownership Distribution Ever wonder if work is fairly distributed? This chart shows exactly who owns how many processes. No more guessing. ![](https://screenshots.tallyfy.com/tableau-samples-4.jpg) **Business Questions Answered:** - Is process ownership evenly distributed? - Are certain users handling a disproportionate amount of work? - Which users are most engaged with the platform? #### 5. Task Completion by User Count completed tasks per person over any time period. You'll quickly see who's handling the heavy lifting - and who has room for more. ![](https://screenshots.tallyfy.com/tableau-samples-5.jpg) **Business Questions Answered:** - Who are your most productive team members? - Is the workload appropriately distributed? - Are any users significantly above or below average completion rates? #### 6. Task-Specific Timeliness Some tasks always run late. Why? This heatmap reveals the problem steps in your processes - darker colors mean more delays. ![](https://screenshots.tallyfy.com/tableau-samples-6.jpg) **Business Questions Answered:** - Which tasks consistently cause delays? - Are there specific steps that should be redesigned? - Do certain task types have longer completion times? #### 7. Process Template Usage Your templates tell a story. Which ones get launched 100 times a month? Which collect dust? Find out here. **Business Questions Answered:** - Which processes are most frequently used? - Are there templates that should be retired or redesigned? - How does template usage vary across departments? #### 8. Daily Task Completion Activity Track daily task completions to spot patterns. Monday madness? Friday slowdowns? The data doesn't lie. ![](https://screenshots.tallyfy.com/tableau-samples-7.jpg) **Business Questions Answered:** - Are there patterns in when work gets completed? - Do we have consistent workflow or significant fluctuations? - Are there days when productivity peaks or drops? ### Process Quality Visualizations #### 9. Comment Frequency Analysis Lots of comments on a task? That's usually a red flag. This visualization pinpoints which steps confuse people most. ![](https://screenshots.tallyfy.com/tableau-samples-8.jpg) **Business Questions Answered:** - Which tasks require the most clarification? - Are there steps that need better documentation? - Where is communication most intensive in our processes? #### 10. Issue Frequency by Task When tasks generate issues, you need to know. This chart ranks your most problematic steps - fix these first for maximum impact. ![](https://screenshots.tallyfy.com/tableau-samples-9.jpg) **Business Questions Answered:** - Which tasks consistently generate problems? - Where should we focus process improvement efforts? - Are specific users experiencing more issues than others? ## Getting Started with These Visualizations Ready to build these yourself? Download our sample Tableau workbook and customize it for your data: 1. Download the [sample Tableau workbook](https://screenshots.tallyfy.com/SAMPLE-WORKBOOK---Athena.zip) 2. Open the workbook in Tableau Desktop 3. Choose **Edit Connection** to connect to your Tallyfy data source 4. Customize the visualizations to match your specific needs ![](https://screenshots.tallyfy.com/tableau-samples-10.jpg) These 10 examples just scratch the surface. Once you connect Tallyfy Analytics to Tableau, you can build hundreds of custom views - each answering your specific workflow questions. - **[Share a Tableau workbook](https://tallyfy.com/products/pro/integrations/analytics/tableau/share-workbook-without-data/)**: Tableau workbooks can be shared securely without exposing sensitive data by disconnecting data sources and allowing recipients to reconnect with their own credentials while preserving all visualizations and dashboard structures. ## Sharing Tableau Workbooks Without Sensitive Data You need to share your Tableau workbook but can't expose your Tallyfy data? Here's how to share visualizations with external parties while keeping your credentials and connection details completely secure. ### Methods for Secure Workbook Sharing | Method | Best For | Data Protection Level | |--------|----------|----------------------| | Data Source Disconnection | One-time sharing | Medium - Structure remains visible | | Data Extraction with Filtering | Recurring sharing | High - Only selected data visible | | Published Data Source | Team collaboration | High - Centralized permission control | ### Requirements - Tableau Desktop installed - Working Tallyfy Analytics connection in Tableau - Visualizations and dashboards already created ## Method 1: Disconnect Data Sources Share your workbook structure - recipients connect their own data. Perfect for one-time sharing. ### Step 1: Prepare Your Workbook Make sure your Tableau workbook has all the visualizations and dashboards you want to share. ![](https://screenshots.tallyfy.com/tableu-share-workbook-1.png) ### Step 2: Disconnect Data Sources Alternatively, you can: ### Step 3: Save and Share the Workbook ### Step 4: Recipient Reconnection Process Recipients will see connection errors when they open the workbook (that's expected!): ![](https://screenshots.tallyfy.com/tableu-share-workbook-7.png) Want more details? Click to see the full error: ![](https://screenshots.tallyfy.com/tableu-share-workbook-8.png) To reconnect to data sources: ## Data Type Configuration Once reconnected, your recipients might need to fix data types - especially dates. Takes about 2 minutes: ## Alternative Sharing Methods ### Method 2: Create a Data Extract with Filtering You want more control? Filter your data before sharing: ### Method 3: Use Tableau Server or Tableau Online Got Tableau Server? This is your best bet for enterprise sharing: ### Method 4: Export Dashboards as PDF/PNG Need a quick share without any connectivity hassles? Export to static files: ## Best Practices for Workbook Sharing A few things to remember: - Remove unnecessary sheets and dashboards before sharing - Document required data sources and connection steps - Test the reconnection process before sharing - Consider creating a template with sample data for demonstration - Remove any sensitive calculations or parameters That's it! You can now share Tableau visualizations while keeping your Tallyfy data completely secure - your recipients just connect their own data sources and they're ready to go. ### Powerbi - **[Connect Power BI](https://tallyfy.com/products/pro/integrations/analytics/powerbi/how-to-analyze-tallyfy-workflows-with-power-bi/)**: Power BI connects to Tallyfy Analytics through Amazon Athena using ODBC drivers and Access Key authentication to create interactive dashboards and visualizations from workflow data with proper configuration taking about 15 minutes to complete. ## Power BI Integration with Tallyfy Analytics Connect Power BI to Tallyfy Analytics and you'll unlock powerful workflow visualization capabilities. Here's how to set up the connection through Amazon Athena[^1] - it takes about 15 minutes from start to finish. ### Integration Benefits - **Advanced Visualization** - Build interactive dashboards showing process bottlenecks and team performance - **Data-Driven Decisions** - Track workflow metrics that actually matter to your business - **Custom Analysis** - Create metrics tailored to your organization's specific KPIs - **Automated Reporting** - Schedule weekly reports that land in stakeholders' inboxes automatically - **Centralized Data** - Merge Tallyfy data with your CRM, ERP, or other business systems ## Connection Architecture This diagram shows how Power BI connects to your Tallyfy data through Amazon Athena. [Diagram removed for brevity] **What to notice:** - The recommended authentication path (Access Key/Secret) leads directly to a successful connection - IAM credentials will cause authentication errors - avoid this path entirely - All connections must go through the us-west-2 region - no other regions will work ## Authentication Methods Amazon Athena hosts your Tallyfy data. You have two ways to authenticate: | Authentication Method | Description | Recommendation | |----------------------|-------------|----------------| | IAM Username/Password | Web console credentials | Not recommended for Power BI | | Access Key/Secret | Token-based authentication | Recommended for Power BI | :::caution[Authentication Best Practice] Token-based authentication is the way to go for Power BI. Why? Using IAM credentials typically triggers this frustrating error: "The security token included in the request is invalid" ::: When Tallyfy activates your Analytics subscription, you get two credential sets. Keep them straight: - **AWS IAM Login** (username/password) - Only for the AWS web console - **Access Key and Secret Access Key** - These are your Power BI connection keys ## Connection Setup Process ### Requirements - Power BI Desktop installed on your computer - Tallyfy Analytics subscription activated - Amazon Athena ODBC driver installed - Authentication credentials provided by Tallyfy ### Step 1: Install the Amazon Athena ODBC Driver ### Step 2: Configure the ODBC Connection Here's exactly what to enter for each setting: | Setting | Value | |---------|-------| | Data Source Name | Tallyfy Analytics | | Description | Tallyfy workflow data | | AWS Region | us-west-2 | | S3 Output Location | As provided by Tallyfy | | Authentication Option | IAM Profile | | Access Key | Your Tallyfy-provided Access Key | | Secret Key | Your Tallyfy-provided Secret Access Key | | Workgroup | Your organization ID (as provided by Tallyfy) | | Catalog | AwsDataCatalog | ### Step 3: Connect Power BI to Amazon Athena ## Working with Tallyfy Data You're connected! Now you can explore these data tables: - **processes** - Track every process instance with its metadata and status - **steps** - Analyze task completion times and identify bottlenecks (see note below about time metrics) - **form_fields** - Extract all the data your teams collect through process forms - **users** - Monitor team member workload and performance metrics :::caution[Time metrics in the steps table] The completion times in the `steps` table show elapsed time, not actual working time. A "3-day" task might be 30 minutes of work interrupted by a weekend. For accurate effort metrics, implement time tracking fields as described in [how to track time spent on tasks](/products/pro/tutorials/how-to/track-time-in-tasks/#analytics-timestamps-inherit-these-challenges). ::: :::tip[Calculating accurate process completion times with NaN handling] The `process_last_modified` field updates whenever a process is edited, archived, or modified - not just when it's completed. For accurate completion time calculations, use the maximum `completed_on` timestamp from all tasks in the process instead. **Important**: Date fields may contain the string "NaN" when the original database value was NULL. Always filter these out to prevent errors. **DAX Formula (Calculated Column) - Process Completion Timestamp:** ```dax Process_Actual_Completion = CALCULATE( MAXX( FILTER( 'Query1', 'Query1'[process_id] = EARLIER('Query1'[process_id]) && 'Query1'[type] = "process_task" && NOT(ISBLANK('Query1'[completed_on])) && 'Query1'[completed_on] <> "nan" ), DATEVALUE('Query1'[completed_on]) + TIMEVALUE('Query1'[completed_on]) ) ) ``` **DAX Formula (Measure) - Average Process Completion Time:** ```dax Average_Process_Completion_Time = VAR ProcessCompletions = ADDCOLUMNS ( SUMMARIZE ( FILTER ( 'Query1', 'Query1'[process_status] = "complete" && 'Query1'[type] = "process_task" ), 'Query1'[process_id] ), "First_Assigned_Date", CALCULATE ( MINX ( FILTER ( 'Query1', NOT(ISBLANK('Query1'[assigned_or_shown_on])) && 'Query1'[assigned_or_shown_on] <> "nan" ), DATEVALUE('Query1'[assigned_or_shown_on]) + TIMEVALUE('Query1'[assigned_or_shown_on]) ) ), "Last_Task_Completed_Date", CALCULATE ( MAXX ( FILTER ( 'Query1', NOT(ISBLANK('Query1'[completed_on])) && 'Query1'[completed_on] <> "nan" ), DATEVALUE('Query1'[completed_on]) + TIMEVALUE('Query1'[completed_on]) ) ) ) RETURN AVERAGEX ( FILTER ( ProcessCompletions, NOT(ISBLANK([First_Assigned_Date])) && NOT(ISBLANK([Last_Task_Completed_Date])) ), DATEDIFF([First_Assigned_Date], [Last_Task_Completed_Date], DAY) ) ``` **Key Points:** - **Timestamp Precision**: Using `DATEVALUE() + TIMEVALUE()` preserves exact completion times down to the second. Using `DATEVALUE()` alone would only give day-level precision, losing hours, minutes, and seconds - resulting in fractional days for sub-day durations (e.g., 2.3 days instead of just 2 days) - Groups by `process_id` ONLY (not by `assigned_or_shown_on`) to avoid duplicate rows - Filters out both ISBLANK and "nan" string values - Calculates when the last task was completed, representing the true process completion timestamp - Works correctly even if processes are archived/unarchived later **Why NaN Appears**: NULL database values → Pandas conversion → Parquet export → string "NaN" ::: ### Important Configuration Notes Here's what catches most people off guard: - You must connect to the **us-west-2** region - other regions won't work - Your workgroup needs to match your organization ID exactly - The catalog name is always **AwsDataCatalog** (yes, with that exact capitalization) - Use Direct Query mode[^2] when working with datasets over 1GB - Set up refresh scheduling if you need reports updated automatically ## Video Tutorial Want to see the whole process in action? Watch this: ## Troubleshooting Connection not working? Let's fix that: - Double-check you're using the Access Key and Secret Access Key - not those IAM credentials - Make sure your ODBC driver is the 64-bit version (32-bit won't work with Power BI Desktop) - Verify you've entered **us-west-2** as the region - it's easy to miss - Check if your Tallyfy Analytics subscription is still active - Sometimes Power BI Desktop needs a restart after configuring ODBC - annoying but it works Still stuck? Contact Tallyfy Support with the exact error message you're seeing. [^1]: A serverless SQL query service that analyzes data in S3 using standard SQL syntax [^2]: Queries data directly from source instead of importing, ideal for large datasets or real-time needs ### Robotics - **[AppTronik Apollo integration](https://tallyfy.com/products/pro/integrations/robotics/apptronik/)**: AppTronik's Apollo humanoid robot designed for industrial applications currently in pilot programs with Mercedes-Benz and GXO Logistics could benefit from Tallyfy integration to address workflow management gaps including static task programming limitations where robots stop for manual updates when encountering new scenarios and individual robot configuration challenges where optimizations don't propagate across fleets along with manual compliance documentation needs that Tallyfy could solve through centralized procedure management automatic audit trails and fleet-wide coordination via :::note[Information Currency] Apollo is currently in pilot deployment phase with commercial scaling planned. Product capabilities and partnerships continue to evolve - verify current status at [apptronik.com](https://apptronik.com/apollo). ::: ## AppTronik Apollo workflow integration AppTronik's Apollo is a humanoid robot designed for industrial applications - standing 5'8" tall and capable of lifting 55 pounds. Apollo is currently being tested in pilot programs with Mercedes-Benz and GXO Logistics. While Google's Gemini integration provides AI capabilities, Apollo lacks dynamic workflow management for enterprise-scale deployments. ## AppTronik Apollo capabilities ### Hardware specifications - **Height**: 1.73 meters (5'8") - **Weight**: 72.6 kg (160 lbs) - **Payload**: 25 kg (55 lbs) - **Battery**: Hot-swappable packs with 4-hour runtime each - **Actuators**: Electric linear actuators for human-like movement - **Safety**: Force control architecture for human collaboration - **Vision**: Stereoscopic cameras for depth perception - **Displays**: E-Ink mouth display and OLED chest screen ### Software platform - **Operating system**: RT Linux for real-time control - **Framework**: ROS (Robot Operating System) - **Interface**: Point-and-click programming interface - **AI integration**: Google Gemini (vision-language-action model) ### Current deployments AppTronik has announced pilot programs with major enterprises: - **Mercedes-Benz**: Testing Apollo in automotive manufacturing facilities (pilot phase) - **GXO Logistics**: Proof-of-concept for warehouse operations (pilot phase) - **Jabil**: Manufacturing partnership for electronics production Deployments remain in pilot phase, with commercial scaling planned as the technology matures. ## Workflow management gaps ### Static task programming Apollo robots execute pre-programmed tasks configured through their control interface. Tasks require specific parameter configuration for each application. When encountering new scenarios outside programmed parameters, robots must stop for manual updates. **Example scenario**: An Apollo sorting packages encounters a new product category. Without programmed handling parameters, the robot stops and waits for operator intervention to update its configuration. **Tallyfy integration approach**: Enable Apollo to query Tallyfy for procedures dynamically, receiving handling instructions, weight limits, and destination zones without stopping operations. ### Individual robot configuration Each Apollo operates with its own task configuration. Optimizations discovered by one robot don't automatically propagate to other units in the fleet. Updates require manual configuration of each robot. **Tallyfy integration approach**: Centralize procedures in Tallyfy so all robots access the same knowledge base. Updates propagate automatically across the fleet. ### Manual compliance documentation Apollo logs movement and task data but doesn't automatically track which procedure version was executed or maintain audit trails for regulatory compliance. **Tallyfy integration approach**: Launch validated processes in Tallyfy that document each step with parameters, creating automatic audit trails for compliance requirements. ## Current Apollo operation model ### Task programming approach Apollo uses a point-and-click interface for task programming. While this simplifies configuration compared to traditional industrial robots, tasks still require parameter setup for each application. Google's Gemini integration provides perception and planning capabilities. Gemini helps Apollo identify objects and plan movements, but business rules and procedures must be defined separately. ### Fleet management considerations With multiple Apollo robots, organizations need to manage: - Task configurations across units - Procedure updates and changes - Performance tracking and optimization - Compliance documentation As deployments scale, centralized procedure management becomes important for maintaining consistency and efficiency across the robot fleet. ## Tallyfy integration architecture ### Integration concept [Diagram removed for brevity] **Integration components:** - ROS bridge connects Apollo's control system to Tallyfy API - Gateway translates between ROS messages and Tallyfy procedures - Gemini handles perception while Tallyfy manages workflow - Process status updates flow back to Tallyfy for tracking ### Technical implementation overview The integration would use a ROS bridge to connect Apollo's control system with Tallyfy's REST API. Key components include: **ROS Integration Layer:** - ROS package that subscribes to Apollo task requests - Queries Tallyfy API for procedure steps - Translates Tallyfy procedures into ROS action sequences - Reports task completion status back to Tallyfy **Procedure Management:** - Store standard operating procedures in Tallyfy templates - Launch processes when Apollo begins tasks - Track step completion with timestamps and parameters - Maintain audit trail of all robot actions **Fleet Coordination:** - Central procedure repository accessed by all robots - Procedure updates propagate automatically - Performance data aggregated across fleet - Compliance documentation generated automatically ## Application scenarios ### Manufacturing environments Apollo robots in manufacturing facilities could benefit from Tallyfy integration through: - Centralized work instructions accessible to all robots - Procedure version control for quality management - Automatic documentation of tasks performed - Compliance tracking for regulated industries ### Warehouse operations In logistics environments, Tallyfy integration could provide: - Dynamic routing based on current warehouse conditions - Standardized handling procedures across robot fleet - Real-time visibility into task progress - Performance metrics aggregated across multiple units ### Regulated industries For pharmaceutical or food production applications, integration benefits include: - Version-controlled validated procedures - Complete audit trails for regulatory compliance - Deviation tracking and management - Batch record generation with all parameters documented ## Integration benefits ### Complementary capabilities **Apollo provides:** - Physical task execution - Object recognition and perception - Safe human collaboration - Mobile manipulation **Tallyfy provides:** - Centralized procedure management - Audit trails and compliance documentation - Process orchestration across multiple robots - Business rule enforcement ### Potential outcomes Organizations deploying Apollo with Tallyfy integration could see: - Reduced time managing robot configurations - Consistent procedures across robot fleet - Automatic compliance documentation - Improved visibility into robot operations - Faster adaptation to procedure changes ## Implementation approach Organizations interested in Apollo-Tallyfy integration should consider: 1. **Assessment**: Document current robot task configurations and workflows 2. **Planning**: Identify procedures suitable for centralized management 3. **Pilot**: Test integration with limited deployment before scaling 4. **Documentation**: Create procedure templates in Tallyfy 5. **Training**: Ensure operators understand integrated system 6. **Scaling**: Expand based on pilot results ## Technical requirements - Apollo robots with ROS access - Network connectivity for API communication - Tallyfy organization with API access - Integration development for ROS bridge - Testing environment ## Apollo commercial status AppTronik has raised significant Series A funding (over $350 million) to scale production of Apollo robots. The company is actively demonstrating useful work with early customers, with full commercialization and scaling planned as the technology proves out in pilot deployments. Tallyfy integration development would align with Apollo's commercial availability timeline. - **[Boston Dynamics integration](https://tallyfy.com/products/pro/integrations/robotics/boston-dynamics/)**: Boston Dynamics Spot robots deployed in over 1500 locations worldwide for industrial inspection face workflow management gaps including static mission recordings that lack conditional logic and no cross-deployment knowledge sharing between facilities which could potentially be addressed through workflow platform integration using Orbit's API and webhook capabilities to provide centralized procedure repositories and compliance documentation. :::note[Information Currency] This article discusses potential integration scenarios between Boston Dynamics Spot robots and workflow management platforms. The integration approaches described are conceptual and not currently implemented features. For current Boston Dynamics capabilities, see their [official documentation](https://dev.bostondynamics.com/)[1]. ::: ## Boston Dynamics Spot workflow integration possibilities Boston Dynamics Spot is deployed in over 1,500 locations worldwide, primarily for industrial inspection and monitoring. The robot uses Orbit fleet management software for mission recording and data collection. This article explores workflow management gaps and potential integration approaches. ## Current Boston Dynamics ecosystem ### What Boston Dynamics provides today **Hardware platform:** - **Spot robot**: Starting at approximately $75,000 for base Explorer Kit (total cost often exceeds $100,000 with attachments) - **Battery life**: Approximately 90 minutes per charge - **Payload capacity**: 14kg - **Mobility**: 1.6 m/s top speed, can climb stairs and traverse rough terrain - **Temperature range**: Extended operating temperature up to 55°C **Software ecosystem:** - **Orbit platform**: Fleet management, data collection, and AI-powered analysis (formerly Scout) - **AI visual inspections**: Automatically detects anomalies like debris, spills, or corrosion - **Site View**: Creates digital twins using 360° images for remote monitoring - **Spot SDK**: Python and C++ APIs for custom development - **Autowalk**: Record missions by walking routes, then play back autonomously - **API and webhooks**: Integration with third-party enterprise systems **Real deployment scale:** - Over 1,500 Spot robots deployed worldwide - Millions of automated data captures performed - Deployed in over 35 countries - Fleet collectively walks enough to circle Earth every three months ## Workflow management gaps ### Static mission recordings Spot missions work by recording specific paths and actions, then playing them back. From Boston Dynamics' SDK documentation, missions follow a "go here, do this" pattern - a linear series of actions at defined locations. **Limitations:** - Missions play back the same way each time - Changes to facility layout require re-recording missions - No conditional logic based on inspection findings - Each mission is a separate file to maintain ### No cross-deployment knowledge sharing Each Spot deployment operates independently: - Inspection improvements at one facility don't transfer to others - Mission files aren't shared between sites - Each deployment recreates similar missions from scratch - No centralized procedure repository ### Procedure documentation challenges Orbit tracks mission execution and data collection: - Records telemetry, sensor data, and timestamps - Shows robot paths and captured images - Provides basic anomaly detection with AI **What's missing:** - Procedural context for why actions were taken - Version control for inspection procedures - Documentation of which regulatory procedures were followed - Standardized compliance reporting across facilities ## How Spot missions work ### Autowalk mission structure Spot uses Autowalk for autonomous navigation. From Boston Dynamics' SDK documentation: **Mission recording:** - Operator drives Spot through the facility using controller - Robot records waypoints and navigation data - Creates a .walk file with linear series of actions - Missions follow "go to location A, perform action 1, go to location B, perform action 2" pattern **Mission playback:** - Robot follows recorded waypoints autonomously - Basic obstacle avoidance lets it navigate around temporary obstacles - If environment changes significantly, mission may fail - Changes require re-recording or editing missions ### Mission management at scale Organizations with large deployments manage many mission files: - Each facility may have dozens or hundreds of missions - Facility changes require updating affected missions - Mission files are maintained per deployment - No built-in system for sharing procedures across sites ## Potential workflow integration approach ### Conceptual architecture A workflow management platform could complement Orbit by providing: **Procedure layer:** - Centralized inspection procedure repository - Version-controlled standard operating procedures - Cross-facility procedure sharing - Compliance documentation templates **Integration points:** - Orbit API for mission status and data - Webhook notifications when missions complete - Custom mission actions calling external APIs - Post-mission workflow triggers ### Example integration pattern [Diagram removed for brevity] **What to notice:** - Orbit handles robot operations and data collection - Workflow platform manages procedures and compliance - Integration happens via APIs and webhooks ## Real-world Spot deployments Boston Dynamics Spot robots are used across various industries: **Industrial inspection:** - National Grid uses Spot at substations, including high-voltage facilities where people cannot enter during operation - AB InBev deployed Spot in their Leuven brewery as part of "Brewery of the Future" program - Purina integrates Spot into predictive maintenance workflows **Hazardous environments:** - UKAEA deployed Spot at Chernobyl with radiation detection payload - Nuclear facilities use Spot for areas with radiation or other hazards - Chemical plants deploy Spot for dangerous area monitoring **Operational scale:** - Spots have automated over 1 million data captures - Fleet takes a tumble approximately once every 50 kilometers - Used for acoustic leak detection, vibration monitoring, and thermal inspections ## Workflow management integration possibilities ### Procedure documentation Organizations using Spot robots could benefit from: - Centralized repository of inspection procedures - Version control for standard operating procedures - Cross-facility procedure sharing - Compliance audit trail generation ### Integration approach Orbit provides API access and webhooks for integration: - Orbit API retrieves mission data and robot status - Webhooks trigger when missions complete - Third-party systems can process inspection data - Custom workflows can route findings to appropriate teams ### Compliance and reporting Workflow platforms could complement Orbit by: - Documenting which procedures were followed during inspections - Generating compliance reports for regulatory audits - Tracking procedure versions used at time of inspection - Creating standardized documentation across facilities ## Available integration options **Orbit capabilities:** - REST API for programmatic data access - Webhook notifications for real-time events - Low-code work order generation (beta) - Integration with enterprise asset management systems - Cloud deployment available globally **Custom development:** - Spot SDK provides Python and C++ APIs - Mission customization through Autowalk extensions - Custom payloads can integrate with external systems - Developer documentation available at dev.bostondynamics.com[2] - **[KUKA Robotics integration](https://tallyfy.com/products/pro/integrations/robotics/kuka/)**: KUKA manufactures industrial robots from 6kg collaborative to 1300kg heavy-duty systems with strong motion control and programming tools like KRL and iiQKA.OS2 but managing procedures and documentation across robot fleets often requires additional workflow systems like Tallyfy to address version control challenges procedure documentation gaps knowledge sharing limitations and audit trail requirements through potential integration via OPC UA or KUKA.Connect protocols. :::note[Information Currency] This article describes potential integration approaches between KUKA robots and Tallyfy. KUKA software and capabilities evolve rapidly - verify current technical specifications and integration requirements with KUKA documentation before implementation. ::: ## KUKA robots and workflow management KUKA manufactures industrial robots ranging from 6kg collaborative robots to 1300kg heavy-duty systems. While KUKA provides strong motion control and programming tools, managing procedures and documentation across robot fleets often requires additional workflow systems. ## KUKA robot ecosystem overview ### Current hardware platforms KUKA's lineup includes several robot families: - **LBR iiwa**: Collaborative 7-axis robots for sensitive assembly tasks - **KR AGILUS**: Light payload robots (6-10kg) for electronics and precision work - **KR SCARA**: High-precision robots (6-12kg) with 0.02mm accuracy - **KR QUANTEC**: Versatile robots with 120-300kg payload capacity - **KR FORTEC**: Heavy-duty robots handling 240-600kg - **KR 1000 TITAN**: Ultra-heavy robots up to 1300kg payload ### Software and programming tools **iiQKA.OS2**: - Web-based programming interface - Virtual robot controller for simulation - AI-ready architecture with optional NVIDIA expansion board - Compatible with existing KRL programs **KUKA.WorkVisual**: - Offline programming and configuration - Field bus setup and I/O mapping - Virtual commissioning capabilities **SmartPAD 2.0**: - Teach pendant for manual programming - Over 250,000 units currently deployed - Cable-connected for safety-rated operation **KUKA Robot Language (KRL)**: - Pascal-based programming language - Precise motion control optimized for KUKA hardware - Consists of .src (movement commands) and .dat (position data) file pairs ## How KUKA programs are deployed ### Traditional KRL programming approach KUKA robots execute programs written in KRL, which requires two files with identical names: - `.src` file: Contains movement commands and logic - `.dat` file: Stores position data and variables Programs are loaded onto robot controllers through several methods: 1. **USB transfer**: Programs copied to USB drives and loaded via controller interface 2. **Network deployment**: Transfer via Ethernet using KUKA.WorkVisual 3. **Teach pendant**: Direct programming on the smartPAD device Each robot controller stores programs locally in the KRC/R1/Programs directory. ### Programming methods **Teach pendant programming**: Manual guidance of robot through positions - time-intensive but doesn't require external tools. **Offline programming**: Create and test programs in simulation before deployment. KUKA.Sim enables virtual commissioning and validation. **Hand guiding**: KUKA's ready2_pilot system uses a 6D joystick for intuitive position teaching. **Text-based KRL**: Direct code writing for programmers familiar with Pascal-like syntax. **Python integration**: KUKA.PythonCore module enables Python-based programming alongside traditional KRL. ## Integration protocols available KUKA robots support standard industrial communication: - **PROFINET**: Industrial Ethernet protocol - **EtherCAT**: Real-time fieldbus system - **OPC UA**: Machine-to-machine communication standard - **KUKA.PLC mxAutomation**: Direct control from Siemens and Rockwell PLCs ## Workflow management gaps ### Challenges in multi-robot deployments When managing multiple KUKA robots, common operational challenges include: **Program version control**: Each robot may run different versions of the same program, making standardization difficult. **Procedure documentation**: Robot execution data (coordinates, timestamps) doesn't automatically link to standard operating procedures or work instructions. **Knowledge sharing**: Optimizations discovered on one robot require manual propagation to other units. **Audit trails**: Connecting robot actions to compliance requirements and quality documentation requires separate systems. **Dynamic updates**: Changing procedures across a robot fleet involves updating programs on each controller individually. ## Potential Tallyfy integration approach Tallyfy could serve as a workflow layer above KUKA's motion control system, addressing documentation and procedure management. ### Integration architecture concept [Diagram removed for brevity] ### What Tallyfy could provide **Procedure documentation**: Link robot tasks to documented SOPs and work instructions. **Process tracking**: Monitor which procedures each robot executes and when. **Audit trails**: Maintain compliance records connecting robot actions to quality requirements. **Fleet visibility**: Dashboard showing all robots and their current process status. **Knowledge base**: Central repository for procedures accessible across all robots. ### Integration requirements Technical prerequisites for integration: - KUKA robots with KRC2, KRC4, or KRC5 controllers - Network connectivity (Ethernet required) - OPC UA or KUKA.Connect for data exchange - Middleware to translate between KUKA protocols and Tallyfy API - Tallyfy organization with API access enabled ## Implementation considerations ### Assessment phase Before implementing workflow integration: 1. Document current KRL programs and associated procedures 2. Identify which processes require audit trails or compliance tracking 3. Evaluate network infrastructure for robot connectivity 4. Determine integration points between KUKA controllers and external systems ### Technical integration options **Option 1: Read-only monitoring** - Track robot status and link to Tallyfy processes without modifying robot programs. **Option 2: Bidirectional integration** - Robot reports completion status; Tallyfy provides procedure parameters. **Option 3: Full workflow control** - Tallyfy initiates robot programs based on process triggers. ### Cost and timeline Integration complexity varies based on approach: - **Read-only monitoring**: Lower complexity, faster deployment - **Bidirectional integration**: Moderate complexity, requires middleware development - **Full workflow control**: Higher complexity, extensive testing required KUKA robots represent significant capital investment. Workflow management integration is a smaller incremental cost focused on operational efficiency. ## Technical requirements summary For workflow integration with KUKA robots: - **Controllers**: KRC2, KRC4, or KRC5 - **Connectivity**: Ethernet network access - **Protocols**: OPC UA or KUKA.Connect preferred - **Middleware**: Custom or third-party integration layer - **Tallyfy access**: API-enabled organization - **[Unitree Robotics integration](https://tallyfy.com/products/pro/integrations/robotics/unitree/)**: Unitree Robotics manufactures quadruped and humanoid robots with SDKs for movement control across industrial inspection and research applications but lacks operational workflow management capabilities that a potential Tallyfy integration could address through dynamic procedure querying and centralized fleet knowledge sharing with compliance documentation. :::note[Information Currency] This article analyzes potential integration opportunities between Unitree Robotics and Tallyfy. Pricing and specifications may change - check Unitree's official site for current details. No official integration exists at this time. ::: ## Unitree Robotics and workflow integration Unitree Robotics manufactures quadruped and humanoid robots with SDKs for movement control. Their hardware serves inspection, security, and research applications. However, like most robotics platforms, they focus on hardware control rather than operational workflow management. ## Unitree robot platforms **Quadruped robots:** - **Go2**: Consumer quadruped with AI vision capabilities (Air, Pro, and Edu variants available) - **B2**: Industrial quadruped for inspection and security applications - **A2**: Industrial model with 100kg load capacity and 20km range - **B2-W**: Hybrid mobility system with wheeled and walking modes **Humanoid robots:** - **G1 Basic**: Entry-level for home use with remote control - **G1 EDU Standard (U1)**: 100 TOPS AI computing, 23 DOF, programmable - **G1 EDU Plus (U2)**: Enhanced waist (3 DOF) and 7 DOF arms (29 total DOF) - **G1 EDU Ultimate A (U3)**: Dex3-1 three-finger hands (43 DOF) - **H1**: Advanced humanoid for research applications Note: The G1 is one of the best-selling humanoid robots with significant market adoption. ## Software capabilities **Development SDKs:** - **unitree_sdk2**: C++ SDK for Go2, B2, H1, G1 using CycloneDDS - **unitree_sdk2_python**: Python interface for robot development - **unitree_legged_sdk**: SDK for Aliengo, A1, Go1, B1 models - **ROS/ROS2 integration**: Native support for robotics middleware - **Simulation support**: MuJoCo and Isaac Lab for virtual testing **Control capabilities:** - Low-level motor control and custom gait development - UDP and DDS communication protocols - SLAM for mapping and autonomous navigation - AI and machine learning integration - Computer vision with NVIDIA Jetson (EDU models) ## Real-world deployments Unitree robots are currently deployed across multiple industries: **Industrial inspection:** - Thermal power plants for automated equipment monitoring - Petrochemical plants in hazardous zones - Power grid substations for infrastructure inspection - Brewery operations for routine checks **Logistics and warehousing:** - Material handling and transport - Inventory monitoring - Warehouse security patrols **Agriculture and environmental:** - Seedling monitoring in farming operations - Terrain assessment and mapping **Research and development:** - Academic research programs - Carnegie Mellon SoFTA project for stable manipulation while walking - Caltech/UT Austin SHIELD safety framework testing **Healthcare and service (emerging):** - Supply delivery assistance - Patient monitoring support - Customer service demonstrations ## Workflow management gaps **Procedure programming:** Unitree robots execute hardcoded Python or C++ scripts deployed individually to each robot. When procedures change, engineers must update code, test in simulation, and redeploy to each unit via SSH. **Knowledge sharing:** No built-in mechanism exists for sharing learnings across robot fleets. Optimizations discovered by one robot remain isolated unless manually coded and deployed to others. **Operational tracking:** Unitree provides telemetry data (battery status, location, sensor readings) but not process-level tracking. No native capability to log which procedures were executed, when tasks were completed, or maintain compliance audit trails. **Multi-robot coordination:** Each robot operates independently with its own code version. No centralized system manages what procedures are deployed where or ensures consistency across fleets. ## How Tallyfy could address workflow gaps **Dynamic procedure management:** Instead of hardcoded scripts, robots could query Tallyfy for current procedures via API. When inspection methods change, updates propagate to all robots without code deployment. **Centralized knowledge base:** Robots could access standardized operating procedures stored in Tallyfy templates. New equipment types or scenarios get documented once and become available fleet-wide. **Process tracking and audit trails:** Robots could launch Tallyfy processes and mark tasks complete with sensor data, photos, and timestamps. This creates compliance documentation and operational visibility. **Fleet-wide improvements:** When optimizations are discovered, they could be documented in Tallyfy procedures and shared across all robots. Changes to SOPs update centrally rather than requiring individual code deployment. ## Potential integration architecture A Tallyfy connector for Unitree could work as middleware between the robot's SDK and Tallyfy's API: [Diagram removed for brevity] **What to notice:** - Connector bridges unitree_sdk2 and Tallyfy REST API - Procedures stored centrally, not in robot code - All operations logged for compliance tracking **Conceptual implementation:** ```python # Hypothetical connector usage from unitree_sdk2_python import Robot import requests robot = Robot() api_key = "your_tallyfy_api_key" # Fetch procedure from Tallyfy response = requests.get( "https://api.tallyfy.com/procedures/solar_inspection", headers={"Authorization": f"Bearer {api_key}"} ) procedure = response.json() # Execute steps and report completion for step in procedure['steps']: # Robot executes based on step data sensor_data = robot.collect_data(step['location']) # Report completion to Tallyfy requests.post( f"https://api.tallyfy.com/tasks/{step['id']}/complete", headers={"Authorization": f"Bearer {api_key}"}, json={"sensor_data": sensor_data} ) ``` Note: This code is conceptual. No official Tallyfy-Unitree connector currently exists. ## Potential use cases **Industrial inspection:** Robots could fetch site-specific inspection procedures from Tallyfy rather than running hardcoded scripts. When equipment types change, procedures update centrally without touching robot code. **Warehouse operations:** Multiple robots could reference the same Tallyfy procedures for patrol routes, inventory checks, or security protocols. Changes to procedures propagate fleet-wide instantly. **Research collaboration:** Academic institutions could share experimental protocols through Tallyfy templates. Each robot would execute identical procedures with automatic data logging for reproducibility. **Compliance documentation:** Operations requiring audit trails (pharmaceutical, food safety, regulated industries) could have robots log every procedure step, timestamp, and sensor reading in Tallyfy for regulatory review. ## Integration requirements **For Unitree robots:** - Compatible models: Go2, B2, A2, G1, H1 - Network connectivity (WiFi or cellular for API access) - Python environment for custom connector code - unitree_sdk2 or unitree_sdk2_python installed **For Tallyfy:** - Organization account with API access - Templates created for robot procedures - API credentials for authentication **Technical considerations:** - Connector middleware development required - Network latency for real-time API calls - Fallback behavior if connectivity lost - Data formatting between SDK and Tallyfy API - **[Universal Robots integration](https://tallyfy.com/products/pro/integrations/robotics/universal-robots/)**: Universal Robots cobots execute static pre-programmed routines stored locally on controllers which creates significant challenges for enterprise workflow management including no dynamic knowledge lookup between robots and isolated program libraries that prevent cross-fleet learning and optimization propagation while lacking the procedural compliance documentation and audit trails needed for regulated industries. :::note[Integration Status] This article describes a **conceptual integration** between Universal Robots and Tallyfy. The Tallyfy URCap referenced does not currently exist as a commercial product. Information about Universal Robots capabilities is based on publicly available documentation. ::: ## Understanding Universal Robots capabilities and workflow gaps Universal Robots has deployed collaborative robots (cobots) across manufacturing facilities worldwide. Their PolyScope X software provides programming capabilities and URCaps enable hardware integration, but the platform uses static programming approaches that create challenges for enterprise workflow management. ## Current Universal Robots ecosystem ### What Universal Robots provides today **Hardware platforms:** - **UR3e**: 3kg payload for precision assembly - **UR5e**: 5kg payload for light assembly and pick-and-place - **UR7e**: 7kg payload for medium-duty applications - **UR10e**: 12.5kg payload for palletizing and machine tending - **UR12e**: 12kg payload for palletizing and machine tending - **UR16e**: 16kg payload for heavy material handling - **UR20**: 20kg payload with 1750mm reach for large parts - **UR30**: 30kg payload for heavy industrial applications **Software ecosystem:** - **PolyScope X**: Latest platform with enhanced UI and progressive disclosure design - Available in 22 languages - Works from any device with a browser - Supports modular programming with reusable functions - Includes Smart Skills for precise positioning - Features Teach Mode for recording complete paths - OptiMove for dynamic speed and acceleration optimization - **PolyScope 5**: Supported on existing e-Series deployments - **URCaps**: Plugin ecosystem for third-party integrations - **UR+**: Marketplace for certified accessories and software - **URSim**: Offline simulation environment - **AI Accelerator**: NVIDIA Isaac integration for computer vision and path planning **Programming capabilities:** - Visual programming with Program Tree interface - URScript scripting language for custom control - Multi-copy/paste of nodes - Nested functions (unlimited depth) - Operator Screen for simplified changeover management - New program nodes: Halt, Timer, Process move, Circular move, Direction until, Switch case - World-centric and tool-centric coordinate frames ## Critical gaps in Universal Robots' workflow system ### 1. No dynamic knowledge lookup **Current state**: UR cobots execute pre-programmed routines stored locally: - Programs are static files on the controller - No ability to query external procedures - Changes require manual reprogramming - Each robot maintains isolated program library **Example problem**: A UR10e performing quality inspection encounters a new product variant. The robot has no program for this variant and stops production. An engineer must create a new program, test it in URSim, and deploy to the robot. **How Tallyfy could address this**: A workflow management layer could allow robots to query standardized procedures for different product variants, reducing the need for individual programs per variant. ### 2. No continuous improvement mechanism **Current state**: Each cobot operates with its own programs: - Optimizations remain local to individual robots - No systematic capture of best practices - Programs don't evolve based on experience - Knowledge lost when operators leave **Example problem**: An operator discovers that a slight wrist rotation improves connector insertion for a UR5e in electronics assembly. This improvement stays locked in that single robot's program unless manually propagated to other units. **How Tallyfy could address this**: When an optimization is discovered, it could be documented in Tallyfy's SOP management system, making the knowledge accessible across robot deployments rather than remaining isolated in individual programs. ### 3. Limited compliance and traceability **Current state**: PolyScope logs robot movements but not procedural compliance: - No record of which SOP version was followed - Limited context for operator interventions - Difficult to prove adherence to quality standards - Manual documentation for audits **Example problem**: A medical device manufacturer uses UR16e robots for sterile packaging. FDA auditors require proof that validated procedures were followed for each batch. PolyScope shows robot logs but can't demonstrate SOP compliance. **How Tallyfy could address this**: Workflow management could provide version-controlled SOPs with electronic documentation of process steps, creating audit trails that link robot operations to validated procedures. ## How Universal Robots ACTUALLY receive and execute instructions ### The reality of UR "collaborative" programming Despite the marketing about "easy programming," here's what actually happens: 1. **Programs are static .urp files stored on the controller**: ```python # This is what a UR program actually looks like def pick_and_place(): movej([1.5, -1.2, 1.0, -0.5, 1.5, 0], a=1.2, v=0.25) # Hardcoded joint positions set_digital_out(0, True) # Activate gripper sleep(0.5) # Hope part is gripped movej([0.5, -0.8, 0.5, -0.2, 1.0, 0], a=1.2, v=0.25) # More hardcoded positions # New part variant? Manually edit all positions ``` **From Universal Robots documentation** ([RoboDK UR Documentation](https://robodk.com/doc/en/Robots-Universal-Robots.html)): - "Save the generated URP file(s) to a USB memory disk and connect to the robot teach pendant" - "URP files are saved in binary format by PolyScope" - not editable without teach pendant - Each robot stores programs locally with no central management - File naming conventions serve as primitive version control 2. **The "intuitive" programming is still rigid**: - Teach pendant lets you create programs visually - But output is still static URScript - Programs can't adapt to variations - IF statements are hardcoded logic, not intelligence - Robot has zero understanding of what it's doing 3. **No improvement or learning mechanism**: - Cobot discovers optimal force for insertion? Stays on that one robot - Process improvement? Manually update every robot's program - No feedback from production to programming - Each robot's experience is isolated ### What happens in production reality **Scenario**: UR10e assembling products with new component variant **What marketing says**: "Flexible automation" and "Easy reprogramming" **What actually happens**: 1. Robot reaches pick position for new component 2. Component is 2mm different height (not in program) 3. Robot either: - Crashes into component (emergency stop) - Grips air (drops part later) - Uses wrong force (damages component) 4. Production stops while engineer: - Edits program on teach pendant - Tests new positions (30-60 minutes) - Saves as "program_v2_new_component.urp" - Manually copies to other robots via USB - Realizes 3 robots still running old version next week ### The real-time tracking joke **What you can see**: - Robot is running "program_42.urp" - Current line number: 47 - I/O status: Output 2 is HIGH **What you actually need for operations**: - "Robot completing step 3 of 8 in assembly process" - "Quality check passed for batch #1234" - "Cycle time trending 5% above target" - "SOP version 2.3 being followed" **Actual UR log data**: ``` 09:15:23 - movej complete 09:15:24 - digital_out_0 = TRUE 09:15:25 - wait 0.5 ``` **What compliance auditors need**: ``` 09:15:23 - Positioned for component pickup (ISO-9001-5.2.1) 09:15:24 - Gripper activated at 45N force (spec: 40-50N) 09:15:25 - Grip validation per QA-PROC-7.2 ``` ### The URCap illusion **URCaps promise**: "Extend robot capabilities!" **URCaps reality**: - Plugins for specific hardware (grippers, cameras) - Still generate static URScript - No dynamic procedure management - No cross-robot communication - Each URCap is another thing to maintain on each robot ### Scaling nightmare with cobots **10 UR robots**: Weekly USB stick tours to update programs **50 UR robots**: Full-time job managing program versions **100+ UR robots**: Complete chaos Real customer quote: "We have 47 URs and honestly don't know which version of which program is on which robot anymore." **Critical limitations from UR forums and documentation**: - [Program size limitations](https://forum.universal-robots.com/t/ur10e-are-there-program-size-limitations/17869): "The robot is unable to cope with programs much larger than 5000 lines" - Programs that work in URSim may fail on physical robots with "ValueStack Full Capacity" errors - [Memory constraints](https://forum.universal-robots.com/t/memory-limit-of-ur10e-controller/33457): Limited controller memory affects complex applications - No built-in fleet management or central program repository in PolyScope ## Conceptual integration architecture ### Theoretical system design [Diagram removed for brevity] **What to notice:** - URCap acts as bridge between robot and workflow system - Gateway handles protocol translation - Status updates flow back for tracking and compliance ### Integration architecture concept A workflow integration would likely involve: **URCap plugin layer**: - Custom URCap developed using Universal Robots SDK - Program nodes that query external workflow system - Installation nodes for workflow system configuration - URScript generation based on workflow definitions **Communication middleware**: - REST API communication between robot and workflow system - Translation of workflow steps to URScript commands - Handling of network failures and offline scenarios - Real-time status updates to workflow platform **Data synchronization**: - Robot telemetry sent to workflow system - Task completion reporting - Quality metrics and sensor data capture - Process step verification and documentation ## Workflow management challenges in robotics ### High-mix manufacturing environments Organizations running multiple product variants face challenges with static robot programming: - Each variant requires separate program development and testing - Program libraries grow large and difficult to manage - Changes to procedures require updating programs across all robots - Knowledge about optimal approaches stays isolated to individual programs ### Regulated industries Medical device and pharmaceutical manufacturers need complete documentation: - Validated procedures must be followed consistently - Audit trails must link robot operations to approved SOPs - Process deviations require documentation and investigation - Manual batch record creation is time-consuming ### Multi-site operations Companies with robot fleets across facilities encounter scaling issues: - Program version management becomes complex - Process improvements at one site don't automatically propagate - Inconsistent practices develop across locations - Training new sites requires significant effort ## Complementary system capabilities ### Robot control system strengths **PolyScope X provides:** - Real-time robot motion control - Safety system monitoring and management - Digital I/O and sensor integration - Force/torque sensing and control - Vision system integration via URCaps - Local program execution and storage - Teach pendant programming interface ### Workflow management system potential **Workflow platforms could provide:** - Centralized procedure library management - Version control for standard operating procedures - Cross-site knowledge sharing - Compliance audit trail generation - Process deviation documentation - Human task coordination with robot operations - Analytics across robot fleet performance ## Potential integration approach A workflow management integration for Universal Robots would need to address several technical challenges: - URCap development compatible with PolyScope X architecture - Translation layer between workflow steps and URScript commands - Real-time communication between robot controllers and workflow system - Handling of network connectivity and failure scenarios - Integration with existing robot safety systems Organizations considering such integration should evaluate: - Current pain points with static programming approaches - Volume of product variants requiring different robot programs - Compliance and traceability requirements - Scale of robot deployments across facilities - Availability of network infrastructure ## Technical considerations A theoretical integration would require: - Universal Robots cobots with PolyScope 5 or PolyScope X - Network connectivity for real-time communication - Custom URCap development for PolyScope integration - Translation layer between workflow definitions and URScript - Workflow management system with API capabilities Organizations interested in exploring workflow management for robotics should assess their specific use cases and technical requirements before evaluating integration feasibility. ### Open api - **[API usage as a third-party application instead of a user](https://tallyfy.com/products/pro/integrations/open-api/access-api-as-a-third-party-application-instead-of-a-user/)**: Third-party applications can integrate with Tallyfy's API using the OAuth 2.0 client credentials flow which involves obtaining client credentials from Tallyfy Support then authenticating to get an application-level token that enables programmatic user provisioning and the generation of user-specific tokens for performing API actions on behalf of individual users within the organization. ## Third-party application integration with Tallyfy API This guide explains how to integrate your application with Tallyfy using the client credentials flow. This allows your application to make Tallyfy API requests on behalf of your users. ### Use cases for on-behalf-of access This integration pattern is useful for organizations that want to: - Embed Tallyfy functionality within their own software - Provide integrated workflow capabilities to their users - Automate process management for clients or employees - Maintain an integrated user experience in their application - Handle user provisioning programmatically ### Implementation overview #### Requirements - Paid Tallyfy Professional or Enterprise subscription - Client credentials (client ID and secret) from Tallyfy - Basic understanding of OAuth 2.0 client credentials flow - Development environment for testing API integration :::caution[Enterprise Feature] The client credentials grant type is only available to paid organizations and is not accessible during free trials. Contact Tallyfy Support to request access to this feature. ::: ## OAuth client credentials flow This diagram shows the complete authentication flow for third-party applications to access Tallyfy on behalf of users. [Diagram removed for brevity] **What to notice:** - The application first authenticates itself with client credentials to get an app-level token - User provisioning and user token generation both require the app-level token, creating a secure chain of trust - Each token type (app vs user) has specific permissions - the app token manages users while user tokens perform actual workflow actions #### Step 1: Request client credentials #### Step 2: Obtain application access token To authenticate your application with Tallyfy, you must first obtain an application-level access token: ``` POST https://account.tallyfy.com/oauth/token ``` **Request Body (form-encoded):** ``` grant_type=client_credentials client_id=12345 client_secret=hTWzy5rpYXcBn8K4J9PqEs2V... scope=* ``` **Headers:** ``` Content-Type: application/x-www-form-urlencoded ``` **Response:** ```json { "token_type": "Bearer", "expires_in": 604800, "access_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..." } ``` :::note[Token Expiration] Application access tokens are valid for 7 days (`expires_in: 604800` seconds). Your application should implement automatic token refresh - simply request a new token before the current one expires. ::: #### Step 3: Provision users programmatically With your application access token, you can create and manage users in your Tallyfy organization: ``` POST https://go.tallyfy.com/api/applications/{orgID}/users ``` **Headers:** ``` Authorization: Bearer {your_app_access_token} Content-Type: application/json X-Tallyfy-Client: APIClient ``` **Request Body:** ```json { "first_name": "John", "last_name": "Smith", "email": "john.smith@yourcompany.com", "role": "standard", "timezone": "America/Chicago" } ``` **Available Roles:** - `admin` - Full organization administration access - `standard` - Regular user with process creation capabilities - `light` - Limited user who can only complete assigned tasks **Response:** ```json { "data": { "id": 12345, "email": "john.smith@yourcompany.com", "first_name": "John", "last_name": "Smith", "role": "standard", "created_at": "2024-01-15T14:22:10.000Z" } } ``` #### Step 4: Generate user-specific access tokens To perform Tallyfy actions on behalf of a specific user, you need to obtain a user-specific token: ``` POST https://go.tallyfy.com/api/applications/{orgID}/users/{email}/token ``` **Headers:** ``` Authorization: Bearer {your_app_access_token} Content-Type: application/json X-Tallyfy-Client: APIClient ``` **Note:** No request body is required - the user's email is specified in the URL path. **Response:** ```json { "token_type": "Bearer", "expires_in": 7776000, "access_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..." } ``` :::note[User Token Validity] User-specific tokens are valid for 3 months (`expires_in: 7776000` seconds). Plan your token refresh strategy accordingly. ::: #### Step 5: Make API requests on behalf of users Use the user-specific token to make Tallyfy API requests as if they were made by the user: ``` GET https://go.tallyfy.com/api/organizations/{orgID}/me/tasks ``` **Headers:** ``` Authorization: Bearer {user_specific_access_token} Content-Type: application/json X-Tallyfy-Client: APIClient ``` :::caution[Required Header] Always include the `X-Tallyfy-Client: APIClient` header in all direct API calls to Tallyfy endpoints. Requests without this header will be rejected. ::: ### Security considerations When implementing on-behalf-of Tallyfy API access: - Store client credentials in secure, encrypted storage - Implement proper access controls to user tokens - Rotate secrets periodically according to your security policies - Validate that user emails belong to your organization before requesting tokens - Use HTTPS for all API communication - Implement token expiration handling and refresh logic ### Troubleshooting | Error | Description | Solution | |-------|-------------|----------| | 401 Unauthorized | Invalid client credentials | Verify client ID and secret | | 403 Forbidden | Insufficient permissions | Ensure the client has appropriate scopes | | 404 Not Found | User not found | Verify the user email and organization ID | | 429 Too Many Requests | Rate limit exceeded | Implement request throttling and retries | For assistance with this integration, contact Tallyfy Support with specific details about your use case and any error messages encountered. - **[Combining RPA systems and human operators](https://tallyfy.com/products/pro/integrations/open-api/how-does-tallyfy-combine-rpa-systems-and-human-operators/)**: Tallyfy serves as an orchestration layer that integrates RPA systems with human workflows to create end-to-end process automation that combines automated tasks with human judgment and decision-making capabilities. ## Integrating RPA systems with human workflows Robotic Process Automation (RPA) excels at automating repetitive, rule-based tasks, but many business processes require a combination of automated and human-driven activities. Tallyfy provides the orchestration layer that connects RPA systems with human workflows, creating complete end-to-end process automation. :::note[API Documentation] For integrating Tallyfy with RPA systems, refer to our [complete API documentation](https://go.tallyfy.com/api/) ::: ### The human-RPA integration challenge RPA platforms like UiPath, Automation Anywhere, and Blue Prism effectively automate predictable, structured tasks. However, most business processes contain elements that require human judgment, decision-making, or exception handling. This creates several challenges: - **Process fragmentation** - Automated and manual steps exist in separate systems - **Visibility gaps** - Limited insight into the complete process status - **Coordination issues** - Difficulty managing handoffs between bots and humans - **Accountability concerns** - Unclear responsibility for process outcomes ### Tallyfy as the orchestration layer Tallyfy addresses these challenges by providing a unified platform that: 1. **Coordinates the entire process** - Manages both automated and human tasks in a single workflow 2. **Provides end-to-end visibility** - Shows status of both RPA and human activities 3. **Facilitates effective handoffs** - Transitions work between systems and people 4. **Maintains accountability** - Tracks responsibility throughout the entire process ### Implementation architecture The typical integration architecture includes: - RPA bots executing automated tasks - Tallyfy API managing the process flow and task assignments - Human operators completing tasks requiring judgment - API-based communication between all systems ### How RPA and human tasks flow together This diagram shows the real-time interaction between RPA systems, Tallyfy's orchestration layer, and human operators during process execution. [Diagram removed for brevity] **What to notice:** - **Seamless handoffs** - Work transitions automatically between RPA bots and human operators through Tallyfy's API orchestration - **Exception handling** - When RPA encounters issues, Tallyfy automatically escalates to human operators for resolution before resuming automation - **Complete visibility** - Every action from both automated and human activities is tracked in real-time through the Tallyfy UI ### Example: employee onboarding process The following screenshot shows how Tallyfy orchestrates an employee onboarding process that combines RPA and human tasks: ![Tallyfy process showing RPA and human task assignments](https://screenshots.tallyfy.com/tallyfy/pro/api-rpa-human-tasks-example.png) In this example: - RPA handles structured tasks like system access provisioning (marked with automation icons) - Human operators manage judgment-based activities like document review - Tallyfy tracks status across both automated and manual steps - The entire process remains visible in a single Tallyfy interface ### Business benefits This integrated approach delivers advantages: - **Process acceleration** - Automation of appropriate tasks while maintaining quality - **Error reduction** - Consistent execution of repetitive activities - **Enhanced visibility** - Complete process transparency across all activities - **Improved adoption** - User-friendly interface for business teams - **Greater flexibility** - Modification of process flows without technical debt For more information on implementing RPA with Tallyfy, visit our [RPA solution page](https://tallyfy.com/solutions/robotic-process-automation-rpa-orchestration-software/) or [schedule a consultation](https://tallyfy.com/booking). - **[API integration guide](https://tallyfy.com/products/pro/integrations/open-api/how-to-integrate-with-tallyfy-using-api/)**: The Tallyfy REST API enables workflow automation through two authentication methods (user-based tokens obtained from Settings or application-based OAuth credentials) requiring specific headers and proper token management while supporting multi-organization contexts and webhook integrations with standardized date formats. ## Tallyfy API integration guide Tallyfy provides a REST API that enables developers to integrate workflow functionality into external applications and systems. :::note[API Documentation] Complete API reference documentation is available at [https://go.tallyfy.com/api/](https://go.tallyfy.com/api/) ::: ## API terminology While the Tallyfy web application uses certain terms in its user interface, the underlying Tallyfy API sometimes uses different terms for the same concepts. Understanding these differences is important when working directly with the API. Here's a mapping of key API objects to their corresponding terms in the Tallyfy **UI**: - API `Checklists` correspond to **Blueprints** in the UI. A **Blueprint** contains **Steps**. - API `Runs` correspond to **Processes** in the UI. A **Process** contains **Tasks**. - API `Captures` correspond to **Task form fields** in the UI. - API `Preruns` correspond to **Kick-off form fields** in the UI. Keeping these distinctions in mind will help you navigate the API documentation and map API data to what users see in the Tallyfy application. ### Required headers All direct API calls to Tallyfy endpoints must include the following header: ``` X-Tallyfy-Client: APIClient ``` **Important**: Requests without this header will be automatically rejected. ### Authentication methods Tallyfy supports two authentication approaches depending on your integration scenario: #### 1. User-based authentication For integrations acting on behalf of a specific Tallyfy user: This video demonstrates how to obtain your access token: #### 2. Application-based authentication For third-party applications or dedicated Tallyfy integrations requiring client credentials: 1. Contact Tallyfy Support with details about your integration requirements 2. Receive your application's **Client ID** and **Client Secret** 3. Implement the OAuth 2.0 flow to obtain and refresh access tokens ## OAuth authentication flow This diagram shows the complete OAuth authentication flow for both user-based and application-based authentication methods. [Diagram removed for brevity] **What to notice:** - Step 1-4 show the initial authentication - choose password grant for user context or client credentials for app-only access - Step 5 demonstrates required headers for all API requests - both Authorization and X-Tallyfy-Client headers are mandatory - Steps 6-10 illustrate automatic token refresh when a 401 error occurs - your application should implement this retry logic ### Best practices for token management To ensure stable API integrations, follow these token management best practices: #### Handling token invalidation Personal access tokens are invalidated when users log out. To minimize disruption: 1. **For automated systems**: Use application tokens (Enterprise plans) instead of personal tokens when possible 2. **For user-based integrations**: - Educate users that logging out will break automations - Implement error handling to detect invalidated tokens - Provide clear instructions for obtaining new tokens after logout 3. **Monitor token health**: Implement logging to track authentication failures and identify patterns #### Token security - Store tokens securely using encryption at rest - Never expose tokens in client-side code or logs - Rotate tokens regularly for sensitive operations - Implement token expiration handling to refresh tokens automatically ### Working with multi-organization users Tallyfy supports users belonging to multiple organizations (tenants). This has important implications for API integrations: #### Organization context in API requests - A user's access token is tied to their current organization context - Tallyfy API requests will operate within the organization context associated with the token - Organization IDs are required in many API endpoints #### Collecting and storing Organization IDs When building integrations that require organization-specific data: 1. Collect the organization ID during user onboarding or application setup 2. Store this ID alongside user credentials in your application 3. Include the organization ID in relevant Tallyfy API requests #### Handling users with multiple organizations For users who belong to multiple organizations: 1. Consider allowing users to select which organization they want to work with 2. Store multiple organization IDs if your application needs to work across organizations 3. Be aware that permissions and available data may vary between organizations 4. For users switching between organizations, you may need to update tokens or credentials :::tip[Organization Switching] Users can switch between organizations in the Tallyfy interface using the Organization Switcher. Learn more in [Switch Between Organizations](/products/pro/settings/personal-settings/how-can-i-switch-between-organizations-in-tallyfy/). ::: ### Obtaining access tokens with password grant If you're receiving a 401 "Unauthenticated" error despite having valid client credentials, you may need to use the password grant authentication flow: :::note[Grant Type Selection] The **client_credentials** grant type will not provide access tokens that work for user-specific endpoints. For accessing standard API endpoints that require user context, you must use the **password** grant type as shown below. ::: 1. Make a POST request to the OAuth token endpoint: ```bash POST https://go.tallyfy.com/api/oauth/token Content-Type: application/x-www-form-urlencoded grant_type=client_credentials& client_id=YOUR_CLIENT_ID& client_secret=YOUR_CLIENT_SECRET ``` 2. You'll receive a response with an access token: ```json { "token_type": "Bearer", "expires_in": 3600, "access_token": "eyJhbGci..." } ``` 3. Use this token in subsequent API requests in the Authorization header: ``` Authorization: Bearer YOUR_ACCESS_TOKEN ``` :::caution[Security Note] The password grant type requires transmitting user credentials. Use this method only in secure environments where you control both the client application and user accounts. ::: ### Understanding grant types | Grant Type | Purpose | Access Context | Suitable For | |------------|---------|----------------|--------------| | **client_credentials** | Application-to-application authentication | Application context only | Backend services, system integrations | | **password** | User-based access via application | Full user context | APIs requiring user permissions, accessing user data | **Important distinction**: - Tokens obtained with `client_credentials` grant type can only access endpoints that don't require user context - Most Tallyfy API endpoints require user context, so the `password` grant is necessary for accessing these endpoints - If you're getting 401 "Unauthenticated" errors when using an access token from `client_credentials`, switch to the `password` grant type ### Token refresh procedure Access tokens expire periodically and must be refreshed for continued API access: 1. Store both the **access_token** and **refresh_token** when first obtained 2. When the access token expires, use the refresh token to obtain a new one 3. Send a POST request to the token endpoint with your refresh token ![Tallyfy API OAuth token endpoint in Swagger](https://screenshots.tallyfy.com/tallyfy/pro/api-oauth-token-swagger.png) This video demonstrates the token refresh process: ### Troubleshooting authentication issues If you encounter authentication problems when using the Tallyfy API, check these common issues: #### 401 Unauthenticated errors 1. **Invalid Token Format**: Ensure your Authorization header uses the exact format: ``` Authorization: Bearer YOUR_ACCESS_TOKEN ``` *Note: There should be exactly one space between "Bearer" and your token.* 2. **Token Expiration**: Tokens typically expire after 1 hour. Implement token refresh logic or request a new token. 3. **Invalid Credentials**: Verify your client ID, client secret, username, and password are correct. 4. **Missing Required Headers**: Ensure all API requests include the `X-Tallyfy-Client: APIClient` header. 5. **Incorrect Token Request**: When requesting a token, verify: - You're using the correct endpoint (`https://go.tallyfy.com/api/oauth/token`) - The `grant_type` parameter matches your authentication flow - All required parameters for your grant type are included 6. **Token Invalidated by Logout**: Personal access tokens are immediately invalidated when users log out of Tallyfy. This common issue affects automations that rely on user tokens. If your automation suddenly stops working, verify the user hasn't logged out. If problems persist, check the response body for specific error messages or contact Tallyfy Support with details about your API implementation and the full error response. #### CORS or preflight issues For cross-origin implementation challenges: - Note any CORS preflight (`OPTIONS`) requests - Check response headers for CORS permissions - Understand allowed origins and methods ### Preventing duplicate operations :::tip[Implement idempotency] When integrating with the Tallyfy API, external systems might send duplicate requests due to network retries, user errors, or webhook events firing multiple times. Implement [idempotency handling](/products/pro/integrations/handling-idempotency-in-webhooks-and-api/) to ensure operations aren't performed multiple times unintentionally. This is especially important when: - Launching processes from external triggers - Updating task form fields - Completing tasks programmatically ::: ### Date format standards When working with dates in the Tallyfy API: | Direction | Format | Example | |-----------|--------|---------| | Request (to API) | YYYY-DD-MM HH:MM:SS | YYYY-15-05 14:30:00 | | Response (from API) | YYYY-MM-DDThh:mm:ss.000Z | YYYY-05-15T14:30:00.000Z | Ensure your code properly handles these date format conventions to avoid errors. ### Webhook integration For event-driven integrations, Tallyfy provides webhook capabilities that don't require direct API calls: - Configure webhooks at the process or step level - Receive real-time notifications when specific events occur - Process the webhook payload to trigger actions in your systems For details on webhook configuration, see the [webhooks setup guide](/products/pro/integrations/webhooks/how-to-set-up-webhooks-in-tallyfy/). - **[Sniff API calls using Chrome](https://tallyfy.com/products/pro/integrations/open-api/how-to-sniff-api-calls-using-chrome/)**: Chrome DevTools enables developers to monitor and analyze Tallyfy's API-first architecture by capturing network requests through the Network tab where you can inspect endpoints headers payloads and responses to understand how to replicate the platform's API calls for custom integrations. ## Monitoring Tallyfy API calls with Chrome DevTools Tallyfy's "API-first" architecture enables developers to understand how the platform communicates with its backend. By inspecting these Tallyfy API calls, you can implement your own integrations. ### Requirements Before starting: - Chrome browser (latest version recommended) - A Tallyfy account with appropriate permissions - Basic understanding of HTTP requests and JSON - Familiarity with the Tallyfy feature you want to analyze :::note[API Documentation] Complete API reference documentation is available at [https://go.tallyfy.com/api/](https://go.tallyfy.com/api/) ::: ### Important API header requirement When making direct API calls to Tallyfy endpoints, you must always include this header: ``` X-Tallyfy-Client: APIClient ``` :::caution[Header Requirement] Requests without this header will be automatically rejected. This is a security measure. ::: ## Capturing API calls with Chrome DevTools ### Setup process ### Analyzing request details #### Request headers section In the **Headers** tab, examine: - **General information**: - Request URL: The full endpoint path - Request method: GET, POST, PUT, DELETE, etc. - Status code: 200 (success), 400 (client error), etc. - **Request Headers**: - `Authorization: Bearer ` for authentication - `X-Tallyfy-Client: APIClient` required for direct API calls - `Content-Type: application/json` for data formatting - **Response Headers**: - Server response metadata - Rate limiting information - Caching directives #### Request payload section For POST, PUT, or PATCH requests: - Click the **Payload** tab to view the request body - Review the following views: - **Form Data**: URL-encoded parameters - **Request Payload**: JSON structure - **View Source**: Raw data exactly as sent - Copy method: #### Response data section Examine the server's response: - Click the **Response** tab to view raw data returned from the server - Click the **Preview** tab to see formatted JSON structure - Analyze: - Data objects and their structure - Success/error messages - Pagination information for list responses - Timestamps and formatting patterns ![Chrome DevTools showing Tallyfy API request payload](https://screenshots.tallyfy.com/tallyfy/pro/api-chrome-devtools-sniff.png) ### Authentication analysis When examining authentication in Tallyfy API calls: - **Bearer Token Format**: Note the structure and length of the JWT token - **Token Lifespan**: Tokens typically expire after a set period - **Scope Information**: What permissions the token includes - **User Context**: Which user the token represents #### Required headers for API replication | Header | Value | Purpose | |--------|-------|---------| | `Authorization` | `Bearer YOUR_TOKEN` | Authentication | | `X-Tallyfy-Client` | `APIClient` | Required identifier | | `Content-Type` | `application/json` | Format specification | | `Accept` | `application/json` | Response format | ### Testing your API understanding To verify you've correctly understood a Tallyfy API call: #### Example cURL command For a typical Tallyfy API call, your cURL might look like: ```bash curl -X POST "https://go.tallyfy.com/api/organizations/{orgID}/processes" \ -H "Authorization: Bearer YOUR_TOKEN" \ -H "Content-Type: application/json" \ -H "X-Tallyfy-Client: APIClient" \ -d '{ "template_id": 12345, "name": "Test Process", "assignees": [{"email": "user@example.com"}] }' ``` ### Advanced DevTools features #### Throttling network speed To test how your Tallyfy API implementation performs under different conditions: #### Exporting request data To save a request for later reference: #### Using Integuru for automated API integration For developers looking to automate API interactions with Tallyfy or other platforms, [Integuru](https://github.com/Integuru-AI/Integuru/) provides an advanced solution. Integuru is an open-source AI agent that can generate integration code by reverse-engineering platforms' internal API Key features: - Automatically generates a dependency graph of API requests - Creates runnable Python code that reproduces your actions - Identifies relationships between different API calls - Handles authentication and session management To use Integuru with Tallyfy: This approach can significantly accelerate API integration development by automatically analyzing the full sequence of API calls needed for complex operations. ### Troubleshooting common issues #### No requests appearing If no API calls appear in DevTools: - Ensure DevTools is open before performing the action - Try enabling **Preserve log** option in the Network tab - Disable cache and perform a hard refresh - Verify you're looking at the correct browser tab - Check if content blockers are interfering with network requests #### Filtering problems If filtering doesn't show expected results: - Verify the filter string exactly matches part of the API URL - Try the built-in **Fetch/XHR** filter instead of text filtering - Clear all filters to check if requests appear at all - Ensure your browser isn't blocking certain requests #### Authentication errors If calls return HTTP 401 or similar errors: - Verify your Tallyfy session is active - Check that your API token is valid and properly formatted - Ensure all required headers are included in your requests - Confirm your user account has permission for the requested action #### CORS or preflight issues For cross-origin implementation challenges: - Note any CORS preflight (`OPTIONS`) requests - Check response headers for CORS permissions - Understand allowed origins and methods ### Security considerations When working with API calls: - **Never share authentication tokens** publicly - **Mask sensitive data** in screenshots or shared requests - **Be aware of data access implications** when replicating calls - **Remember that all actions through the API are tracked** in audit logs - **[OAuth authorization flow for third-party applications](https://tallyfy.com/products/pro/integrations/open-api/oauth-authorization-flow/)**: This guide demonstrates implementing OAuth 2.0 authorization flow for third-party applications to authenticate with Tallyfy without exposing user credentials through a secure redirect-based process that returns access tokens for API authentication. ## Implementing the OAuth authorization flow This guide explains how to implement a standard OAuth authorization flow for third-party applications integrating with Tallyfy. This approach allows your users to authenticate directly with Tallyfy without sharing their credentials with your application. ### Requirements - Paid Tallyfy Professional or Enterprise subscription - Client ID and Client Secret from Tallyfy - A registered redirect URI for your application - Basic understanding of OAuth 2.0 authorization flows :::caution[Enterprise Feature] The OAuth authorization flow is only available to paid organizations. Contact Tallyfy Support to request a Client ID and Client Secret for your application. ::: ### Standard OAuth flow implementation The following diagram shows the complete OAuth 2.0 implicit flow for authenticating third-party applications with Tallyfy. [Diagram removed for brevity] **Diagram description:** OAuth 2.0 implicit flow showing the 11-step authentication process where users authenticate directly with Tallyfy without sharing credentials with third-party applications. The flow shows how access tokens are returned via URL fragments for security, with the third-party app extracting the token and using it for API requests with proper Bearer authorization headers. **Key security features:** - The access token is returned in the URL fragment (after #) for security - fragments are not sent to servers - Authentication happens entirely on Tallyfy's domain, your app never sees user credentials - The `X-Tallyfy-Client` header is required for all API calls after authentication #### Step 1: Redirect users to Tallyfy authorization page Direct your users to the Tallyfy authorization endpoint: ``` https://account.tallyfy.com/oauth/authorize?client_id=YOUR_CLIENT_ID&response_type=token&redirect_uri=YOUR_REDIRECT_URL ``` Replace: - `YOUR_CLIENT_ID` with your application's client ID - `YOUR_REDIRECT_URL` with your application's registered redirect URI Users will see the Tallyfy login page where they can authenticate using their Tallyfy credentials. #### Step 2: Handle the redirect with access token After successful authentication, Tallyfy redirects the user back to your specified redirect URI with the access token in the URL fragment: ``` YOUR_REDIRECT_URL?access_token=ACCESS_TOKEN&token_type=Bearer&expires_in=EXPIRES_IN_SECONDS ``` Your application should: 1. Extract the `access_token` from the URL 2. Store it securely 3. Use it for subsequent API requests #### Step 3: Make API requests with the access token Use the access token in the Authorization header for all Tallyfy API requests: ``` Authorization: Bearer ACCESS_TOKEN Content-Type: application/json X-Tallyfy-Client: APIClient ``` :::note[Required Headers] Always include the `X-Tallyfy-Client: APIClient` header in all direct API calls to Tallyfy endpoints. Requests without this header will be rejected. ::: ### Example implementation #### Example authorization URL ``` https://account.tallyfy.com/oauth/authorize?client_id=9999&response_type=token&redirect_uri=https://yourapp.com/auth/callback ``` #### Example redirect with access token ``` https://yourapp.com/auth/callback?access_token=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...&token_type=Bearer&expires_in=840 ``` #### Handling multi-organization users A user in Tallyfy can belong to multiple organizations. After authentication, the access token is associated with the organization the user is currently logged into. If your application needs to work with multiple Tallyfy organizations for a user: 1. Store the organization context along with the access token 2. Consider implementing organization selection in your application 3. For users in multiple organizations, you may need to handle organization-specific authentication flows ### Security best practices - Always use HTTPS for all OAuth-related communication - Implement PKCE (Proof Key for Code Exchange) for added security - Store access tokens securely, preferably encrypted - Implement token expiration handling - Never expose your Client Secret in client-side code - Validate all redirect URIs against expected patterns - Implement state parameter to prevent CSRF attacks ### Troubleshooting | Issue | Possible Cause | Solution | |-------|----------------|----------| | Authorization fails | Invalid client ID | Verify your client ID | | Redirect fails | Mismatched redirect URI | Ensure the redirect URI matches exactly with the registered one | | Token doesn't work | Token expired | Check expiration time and request a new token | | Organization context issues | User belongs to multiple organizations | Clarify organization context during authentication | For any issues with the OAuth implementation, contact Tallyfy Support with detailed information about the error and your implementation. - **[API clients](https://tallyfy.com/products/pro/integrations/open-api/api-clients/)**: Tallyfy's REST API supports popular development tools like Postman to help developers test endpoints interactively explore the API generate code snippets and debug authentication issues with comprehensive guides covering authentication templates processes and advanced integration patterns. Tallyfy's REST API works with any HTTP client. These guides help you get started with popular API testing and development tools. ## Available client guides - **[Postman](/products/pro/integrations/open-api/api-clients/postman/)** - The most popular API testing platform with a visual interface for testing Tallyfy endpoints ## Why use API clients? API clients help you: - Test Tallyfy endpoints without writing code - Explore the API interactively - Generate code snippets automatically - Share API collections with team members - Debug authentication and request issues Each guide provides Tallyfy-specific examples, authentication setup, and common workflow patterns to accelerate your integration development. - **[API code samples](https://tallyfy.com/products/pro/integrations/open-api/code-samples/)**: The Tallyfy REST API documentation provides code samples across multiple programming languages for integrating with the platform using proper authentication headers and base URL endpoints. This section provides practical code examples for common operations using the Tallyfy REST API. Select a category below to find samples in Javascript, Python, Java, and Go. Choose a category to get started: All code examples assume you have obtained your **Personal Access Token** or generated appropriate OAuth tokens for Tallyfy. The base URL for API calls (unless otherwise noted) is `https://go.tallyfy.com/api`. Remember to include the following headers in your requests: - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` - `Content-Type: application/json` (for requests with a JSON body, like POST or PUT) ### Api clients - **[Getting started with Postman API testing](https://tallyfy.com/products/pro/integrations/open-api/api-clients/postman/)**: This guide shows how to set up Postman with Tallyfy's API for testing workflow automation endpoints including authentication configuration environment setup and common operations like launching processes and completing tasks. To test Tallyfy's API with Postman, set up authentication with your API credentials, then import our collection to explore endpoints for templates, processes, and tasks. This guide walks you through complete setup and provides real examples. ## What is Postman and why use it with Tallyfy? Postman helps you test API endpoints without writing code. For Tallyfy, this means you can quickly: - Launch processes programmatically - Update task statuses in bulk - Export workflow data - Test integrations before building them Think of Postman as your Tallyfy API playground - perfect for exploring what's possible before committing to code. ## Prerequisites Before starting, you need: - A Tallyfy account with API access enabled - Postman desktop app or web version (free at [postman.com](https://www.postman.com)[1]) - Your Tallyfy API credentials (found in Settings > API) ## Quick setup ## Common Tallyfy API operations Here are the most useful endpoints for workflow automation: ### Launch a process from template ``` POST /organizations/{{TALLYFY_ORG_ID}}/templates/{{TEMPLATE_ID}}/launch ``` ### Complete a task ``` PUT /tasks/{{TASK_ID}}/complete ``` ### List all active processes ``` GET /organizations/{{TALLYFY_ORG_ID}}/processes?status=active ``` ### Upload file to task ``` POST /tasks/{{TASK_ID}}/files ``` ## What will I find in this guide? This complete Postman guide is organized into focused sections: ### Postman - **[Advanced patterns and testing](https://tallyfy.com/products/pro/integrations/open-api/api-clients/postman/advanced-patterns/)**: This guide explains how to implement advanced Postman workflows for Tallyfy API testing including multi-organization environment switching and cross-org data comparison along with performance monitoring through response time tracking and endpoint analysis plus mock server configuration for simulating various API conditions and comprehensive CI/CD integration using Newman with GitHub Actions for automated testing pipelines and data-driven testing approaches using CSV and JSON files. To implement advanced Postman workflows with Tallyfy's API, use collection runners for bulk operations, Newman for CI/CD integration, and monitors for scheduled checks. These patterns help scale from manual testing to automated workflow management. ## Multi-organization testing Many users work across multiple Tallyfy organizations. Here's how to test efficiently: ### Environment switching setup Create separate environments for each organization: ```javascript // Pre-request script to rotate organizations const orgs = [ { name: "Production", id: "org_prod_123", clientId: "client_prod", clientSecret: pm.environment.get("PROD_SECRET") }, { name: "Staging", id: "org_stage_456", clientId: "client_stage", clientSecret: pm.environment.get("STAGE_SECRET") }, { name: "Development", id: "org_dev_789", clientId: "client_dev", clientSecret: pm.environment.get("DEV_SECRET") } ]; // Get current org index let currentIndex = pm.variables.get("ORG_INDEX") || 0; // Set current org variables const currentOrg = orgs[currentIndex]; pm.environment.set("TALLYFY_ORG_ID", currentOrg.id); pm.environment.set("TALLYFY_CLIENT_ID", currentOrg.clientId); pm.environment.set("TALLYFY_CLIENT_SECRET", currentOrg.clientSecret); console.log(`Testing with ${currentOrg.name} organization`); // Rotate to next org for next run const nextIndex = (currentIndex + 1) % orgs.length; pm.variables.set("ORG_INDEX", nextIndex); ``` ### Cross-org data comparison Compare processes across organizations: ```javascript // After getting processes from multiple orgs const orgProcesses = pm.environment.get("ORG_PROCESSES") || {}; const currentOrg = pm.environment.get("TALLYFY_ORG_ID"); // Store current org's processes orgProcesses[currentOrg] = pm.response.json().data; pm.environment.set("ORG_PROCESSES", orgProcesses); // If we have data from all orgs, compare const orgIds = Object.keys(orgProcesses); if (orgIds.length >= 3) { console.log("Process count comparison:"); orgIds.forEach(orgId => { const count = orgProcesses[orgId].length; console.log(`${orgId}: ${count} active processes`); }); // Find processes with same name across orgs const processNames = new Set(); orgIds.forEach(orgId => { orgProcesses[orgId].forEach(p => processNames.add(p.name)); }); console.log("\nCommon process names across orgs:"); processNames.forEach(name => { const orgsWithProcess = orgIds.filter(orgId => orgProcesses[orgId].some(p => p.name === name) ); if (orgsWithProcess.length > 1) { console.log(`"${name}" exists in ${orgsWithProcess.length} orgs`); } }); } ``` ## Performance monitoring Track API performance to identify bottlenecks: ### Response time tracking ```javascript // Add to collection's Tests tab pm.test("Response time is acceptable", function () { const maxTime = 1000; // 1 second pm.expect(pm.response.responseTime).to.be.below(maxTime); }); // Track performance over time const perfData = pm.environment.get("PERFORMANCE_DATA") || []; perfData.push({ endpoint: pm.request.url.toString(), method: pm.request.method, responseTime: pm.response.responseTime, timestamp: new Date().toISOString(), status: pm.response.code }); // Keep last 100 entries if (perfData.length > 100) { perfData.shift(); } pm.environment.set("PERFORMANCE_DATA", perfData); // Analyze trends const recentTimes = perfData.slice(-10).map(d => d.responseTime); const avgTime = recentTimes.reduce((a, b) => a + b, 0) / recentTimes.length; if (avgTime > 800) { console.warn(`Performance degradation detected. Average response time: ${avgTime}ms`); } ``` ### Endpoint performance comparison ```javascript // Aggregate performance by endpoint const perfData = pm.environment.get("PERFORMANCE_DATA") || []; const endpointStats = {}; perfData.forEach(entry => { const endpoint = entry.endpoint.replace(/\/[a-f0-9\-]+/g, '/:id'); // Normalize IDs if (!endpointStats[endpoint]) { endpointStats[endpoint] = { count: 0, totalTime: 0, maxTime: 0, minTime: Infinity }; } const stats = endpointStats[endpoint]; stats.count++; stats.totalTime += entry.responseTime; stats.maxTime = Math.max(stats.maxTime, entry.responseTime); stats.minTime = Math.min(stats.minTime, entry.responseTime); }); console.log("Endpoint Performance Report:"); Object.entries(endpointStats).forEach(([endpoint, stats]) => { const avgTime = (stats.totalTime / stats.count).toFixed(0); console.log(`${endpoint}:`); console.log(` Calls: ${stats.count}`); console.log(` Avg: ${avgTime}ms`); console.log(` Min: ${stats.minTime}ms`); console.log(` Max: ${stats.maxTime}ms`); }); ``` ## Mock server setup Postman mock servers simulate API behavior for testing and development. Unlike simple stubs, they use sophisticated matching algorithms. ### Advanced mock server creation **Expert insight**: Mock servers in Postman use a request-response matching algorithm that considers HTTP method, path, query parameters, and custom headers (x-mock-response-code, x-mock-response-id, x-mock-response-name). 1. **Intelligent example capture**: ```javascript // Enhanced response capturing with metadata if (pm.response.code >= 200 && pm.response.code < 400) { const examples = pm.environment.get("MOCK_EXAMPLES") || {}; const endpoint = pm.request.url.getPath(); const method = pm.request.method; const key = `${method}_${endpoint.replace(/\//g, '_')}`; examples[key] = { request: { method: method, url: pm.request.url.toString(), headers: pm.request.headers.toObject(), body: pm.request.body ? pm.request.body.raw : null }, response: { status: pm.response.code, headers: pm.response.headers.toObject(), body: pm.response.text(), responseTime: pm.response.responseTime }, timestamp: new Date().toISOString() }; pm.environment.set("MOCK_EXAMPLES", examples); console.log(`Captured example for ${key}`); } ``` 2. **Dynamic mock server configuration**: ```javascript // Smart mock/real server switching const mockConfig = { development: { useMock: true, mockUrl: "https://mock-server-123.pstmn.io", scenarios: ["success", "error", "timeout"] }, staging: { useMock: false, realUrl: "https://go.tallyfy.com/api" }, production: { useMock: false, realUrl: "https://go.tallyfy.com/api" } }; const environment = pm.environment.get("TARGET_ENV") || "development"; const config = mockConfig[environment]; if (config.useMock) { pm.request.url.host = config.mockUrl.replace(/https?:\/\//, '').split('/'); pm.request.url.protocol = "https"; // Add mock scenario headers const scenario = pm.environment.get("MOCK_SCENARIO") || "success"; pm.request.headers.add({ key: 'x-mock-response-name', value: scenario }); } ``` 3. **Mock server error simulation**: ```javascript // Simulate various API conditions const errorSimulation = { "rate_limit": { code: 429, headers: {"x-mock-response-code": "429"}, delay: 1000 }, "server_error": { code: 500, headers: {"x-mock-response-code": "500"} }, "timeout": { code: 408, headers: {"x-mock-response-code": "408"}, delay: 30000 } }; const simulateError = pm.environment.get("SIMULATE_ERROR"); if (simulateError && errorSimulation[simulateError]) { const error = errorSimulation[simulateError]; Object.entries(error.headers).forEach(([key, value]) => { pm.request.headers.add({key, value}); }); } ``` ### End-to-end testing with mock servers **Best practice insight**: Use mock servers to test system resilience without relying on external APIs you can't control. ```javascript // E2E test pattern with mocked dependencies const testScenarios = { "happy_path": { mockResponses: ["success", "success", "success"], expectedOutcome: "process_completed" }, "partial_failure": { mockResponses: ["success", "error", "success"], expectedOutcome: "process_retry" }, "complete_failure": { mockResponses: ["error", "error", "error"], expectedOutcome: "process_failed" } }; const currentScenario = pm.environment.get("E2E_SCENARIO") || "happy_path"; const scenario = testScenarios[currentScenario]; // Set up mock responses for this scenario scenario.mockResponses.forEach((response, index) => { pm.environment.set(`MOCK_STEP_${index + 1}`, response); }); ``` ## CI/CD integration ### Newman vs Postman CLI: Choose the right tool You have two options for command-line collection execution: | Feature | Newman | Postman CLI | |---------|--------|-----------| | **Installation** | `npm install -g newman` | Download from Postman | | **Authentication** | API key only | Full OAuth support | | **Cloud features** | Limited | Full workspace sync | | **CI/CD integration** | Mature ecosystem | Newer, growing | | **Extensibility** | Rich plugin system | Limited but improving | **Newman setup for automated testing**: ```bash # Install Newman (requires Node.js v16+) npm install -g newman # Verify installation newman --version ``` **Advanced Newman execution patterns**: ```bash # Basic run with full reporting newman run tallyfy-api.postman_collection.json \ -e production.postman_environment.json \ --reporters cli,json,html \ --reporter-json-export results.json \ --reporter-html-export report.html \ --delay-request 100 \ --timeout-request 30000 # Parallel execution with data-driven testing newman run collection.json \ -e environment.json \ -d test-data.csv \ --iteration-count 5 \ --parallel # Advanced error handling newman run collection.json \ --bail failure \ --ignore-redirects \ --disable-unicode \ --global-var "API_BASE=https://go.tallyfy.com/api" ``` **Expert Newman configuration**: ```bash # Custom delay patterns for rate limiting newman run collection.json \ --delay-request 200 \ --timeout-request 10000 \ --timeout-script 5000 # Selective execution newman run collection.json \ --folder "Authentication Tests" \ --env-var "SKIP_CLEANUP=true" # Output management newman run collection.json \ --reporter-cli-no-summary \ --reporter-cli-no-failures \ --reporter-json-export results.json \ --reporter-html-export detailed-report.html ``` ### GitHub Actions integration **Production-ready CI/CD pipeline with advanced error handling**: `.github/workflows/api-tests.yml`: ```yaml name: Tallyfy API Tests on: schedule: - cron: '0 */4 * * *' # Every 4 hours workflow_dispatch: push: branches: [main, develop] pull_request: branches: [main] env: NODE_VERSION: '18' NEWMAN_VERSION: 'latest' jobs: api-tests: runs-on: ubuntu-latest strategy: matrix: environment: [staging, production] test-suite: [smoke, full, regression] steps: - uses: actions/checkout@v4 - name: Setup Node.js uses: actions/setup-node@v4 with: node-version: ${{ env.NODE_VERSION }} cache: 'npm' - name: Install Newman and reporters run: | npm install -g newman@${{ env.NEWMAN_VERSION }} npm install -g newman-reporter-slack npm install -g newman-reporter-teamcity - name: Validate collection syntax run: | newman run postman/tallyfy-api.json --dry-run - name: Run API Tests - ${{ matrix.environment }} - ${{ matrix.test-suite }} env: TALLYFY_CLIENT_ID: ${{ secrets[format('TALLYFY_CLIENT_ID_{0}', matrix.environment)] }} TALLYFY_CLIENT_SECRET: ${{ secrets[format('TALLYFY_CLIENT_SECRET_{0}', matrix.environment)] }} SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK_URL }} run: | newman run postman/tallyfy-api.json \ -e postman/${{ matrix.environment }}.json \ --folder "${{ matrix.test-suite }}" \ --env-var "TALLYFY_CLIENT_ID=$TALLYFY_CLIENT_ID" \ --env-var "TALLYFY_CLIENT_SECRET=$TALLYFY_CLIENT_SECRET" \ --reporters cli,json,html,slack \ --reporter-json-export results-${{ matrix.environment }}-${{ matrix.test-suite }}.json \ --reporter-html-export report-${{ matrix.environment }}-${{ matrix.test-suite }}.html \ --reporter-slack-webhookurl "$SLACK_WEBHOOK" \ --delay-request 100 \ --timeout-request 30000 \ --bail failure continue-on-error: true - name: Parse test results id: test-results run: | RESULT_FILE="results-${{ matrix.environment }}-${{ matrix.test-suite }}.json" if [ -f "$RESULT_FILE" ]; then TOTAL=$(jq '.run.stats.requests.total' "$RESULT_FILE") FAILED=$(jq '.run.stats.requests.failed' "$RESULT_FILE") ASSERTIONS_FAILED=$(jq '.run.stats.assertions.failed' "$RESULT_FILE") echo "total_requests=$TOTAL" >> $GITHUB_OUTPUT echo "failed_requests=$FAILED" >> $GITHUB_OUTPUT echo "failed_assertions=$ASSERTIONS_FAILED" >> $GITHUB_OUTPUT # Calculate success rate SUCCESS_RATE=$(echo "scale=2; ($TOTAL - $FAILED) * 100 / $TOTAL" | bc) echo "success_rate=$SUCCESS_RATE" >> $GITHUB_OUTPUT fi - name: Upload test artifacts uses: actions/upload-artifact@v4 if: always() with: name: test-results-${{ matrix.environment }}-${{ matrix.test-suite }} path: | results-*.json report-*.html retention-days: 30 - name: Comment PR with results if: github.event_name == 'pull_request' uses: actions/github-script@v7 with: script: | const successRate = '${{ steps.test-results.outputs.success_rate }}'; const totalRequests = '${{ steps.test-results.outputs.total_requests }}'; const failedRequests = '${{ steps.test-results.outputs.failed_requests }}'; const comment = ` ## 🧪 API Test Results - ${{ matrix.environment }} - ${{ matrix.test-suite }} - **Success Rate**: ${successRate}% - **Total Requests**: ${totalRequests} - **Failed Requests**: ${failedRequests} [View detailed results](https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}) `; github.rest.issues.createComment({ issue_number: context.issue.number, owner: context.repo.owner, repo: context.repo.repo, body: comment }); - name: Fail if tests failed if: steps.test-results.outputs.failed_requests > 0 run: | echo "❌ API tests failed: ${{ steps.test-results.outputs.failed_requests }} out of ${{ steps.test-results.outputs.total_requests }} requests failed" exit 1 notification: needs: api-tests runs-on: ubuntu-latest if: always() steps: - name: Notify team of results uses: 8398a7/action-slack@v3 with: status: ${{ job.status }} text: 'Tallyfy API tests completed' env: SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }} ``` ### Advanced CI/CD patterns **Performance regression detection**: ```bash # Add to Newman command for performance tracking newman run collection.json \ --reporters cli,json \ --reporter-json-export current-results.json # Compare with baseline (add to CI script) node scripts/performance-comparison.js \ --baseline baseline-results.json \ --current current-results.json \ --threshold 20 # 20% performance degradation threshold ``` **Environment-specific test execution**: ```yaml # Advanced environment matrix strategy: matrix: include: - environment: staging test-type: smoke timeout: 10000 - environment: staging test-type: full timeout: 30000 - environment: production test-type: health-check timeout: 5000 ``` ### Data-driven testing Postman supports both CSV and JSON data files for thorough data-driven testing approaches. **CSV format for simple data sets**: `test-data.csv`: ```csv process_name,template_id,assignee,priority,expected_status,deadline_days "Q1 Budget Review","template_123","john@company.com","high","active",7 "Employee Onboarding","template_456","hr@company.com","medium","pending",14 "Equipment Request","template_789","it@company.com","low","draft",30 ``` **JSON format for complex data structures**: `test-data.json`: ```json [ { "process_name": "Q1 Budget Review", "template_id": "template_123", "assignee": "john@company.com", "priority": "high", "kick_off_data": { "field_department": "Finance", "field_budget_amount": 50000, "field_approval_required": true }, "expected_tasks": 5, "validation_rules": { "response_time_max": 2000, "required_fields": ["id", "name", "status"] } } ] ``` **Advanced Newman execution with data**: ```bash # Run with multiple data sets and detailed reporting newman run collection.json \ -e environment.json \ -d test-data.json \ --iteration-count 3 \ --delay-request 500 \ --reporters cli,json,html \ --reporter-html-template custom-template.hbs \ --reporter-json-export detailed-results.json # Parallel execution for performance testing newman run collection.json \ -d large-dataset.csv \ --parallel \ --reporter-cli-no-assertions \ --reporter-cli-no-console ``` **Dynamic data generation in scripts**: ```javascript // Access CSV/JSON data in Postman scripts const processName = pm.variables.get("process_name"); const templateId = pm.variables.get("template_id"); const kickOffData = JSON.parse(pm.variables.get("kick_off_data") || '{}'); // Dynamic validation based on data const expectedTasks = parseInt(pm.variables.get("expected_tasks")); const validationRules = JSON.parse(pm.variables.get("validation_rules") || '{}'); pm.test(`Process has expected ${expectedTasks} tasks`, () => { const process = pm.response.json(); pm.expect(process.tasks).to.have.lengthOf(expectedTasks); }); // Validate response time based on data if (validationRules.response_time_max) { pm.test(`Response time under ${validationRules.response_time_max}ms`, () => { pm.expect(pm.response.responseTime).to.be.below(validationRules.response_time_max); }); } // Validate required fields from data if (validationRules.required_fields) { validationRules.required_fields.forEach(field => { pm.test(`Response has required field: ${field}`, () => { pm.expect(pm.response.json()).to.have.property(field); }); }); } ``` **Data-driven error scenario testing**: ```json [ { "scenario": "invalid_template_id", "template_id": "invalid_123", "expected_status": 404, "expected_error": "Template not found" }, { "scenario": "missing_required_field", "template_id": "template_123", "kick_off_data": {}, "expected_status": 422, "expected_error": "Validation failed" } ] ``` ```javascript // Test error scenarios from data const scenario = pm.variables.get("scenario"); const expectedStatus = parseInt(pm.variables.get("expected_status")); const expectedError = pm.variables.get("expected_error"); pm.test(`${scenario} returns expected status ${expectedStatus}`, () => { pm.expect(pm.response.code).to.equal(expectedStatus); }); if (expectedError) { pm.test(`${scenario} returns expected error message`, () => { const response = pm.response.json(); pm.expect(response.error || response.message).to.include(expectedError); }); } ``` ## Collection runner patterns ### Workflow simulation Simulate complete workflows: ```javascript // Collection structure: // 1. Authenticate // 2. Create Process // 3. Complete Task 1 // 4. Complete Task 2 // 5. Add Comment // 6. Complete Final Task // 7. Verify Process Complete // Pass data between requests // In "Create Process" Tests: const processId = pm.response.json().id; pm.collectionVariables.set("CURRENT_PROCESS_ID", processId); // In subsequent requests, use: // {{CURRENT_PROCESS_ID}} ``` ### Parallel execution with async Run multiple operations concurrently: ```javascript // Execute multiple API calls in parallel async function parallelOperations() { const operations = [ { name: "List Templates", endpoint: "/checklists" }, { name: "List Processes", endpoint: "/runs" }, { name: "List Tasks", endpoint: "/me/tasks" }, { name: "List Members", endpoint: "/members" } ]; const results = await Promise.all( operations.map(op => pm.sendRequest({ url: `${pm.environment.get("TALLYFY_BASE_URL")}/organizations/${pm.environment.get("TALLYFY_ORG_ID")}${op.endpoint}`, method: 'GET', header: { 'Authorization': `Bearer ${pm.environment.get("TALLYFY_ACCESS_TOKEN")}`, 'X-Tallyfy-Client': 'APIClient' } }).then(response => ({ name: op.name, status: response.code, count: response.json().data?.length || 0, time: response.responseTime })) ) ); console.log("Parallel operation results:"); results.forEach(r => { console.log(`${r.name}: ${r.count} items in ${r.time}ms`); }); const totalTime = Math.max(...results.map(r => r.time)); console.log(`Total parallel execution time: ${totalTime}ms`); } parallelOperations(); ``` ## Monitoring and alerting ### Scheduled monitors Set up Postman monitors for continuous checking: 1. **Process health check**: ```javascript // Monitor collection to run every hour pm.test("No stuck processes", function() { const processes = pm.response.json().data; const stuckCount = processes.filter(p => { const hoursSinceUpdate = (Date.now() - new Date(p.updated_at)) / (1000 * 60 * 60); return hoursSinceUpdate > 24 && p.status === 'active'; }).length; pm.expect(stuckCount).to.equal(0); }); ``` 2. **API availability**: ```javascript pm.test("API is responsive", function() { pm.response.to.have.status(200); pm.expect(pm.response.responseTime).to.be.below(2000); }); ``` ### Slack integration for alerts Send alerts when monitors detect issues: ```javascript // In monitor's Tests tab if (pm.test.failures && pm.test.failures.length > 0) { const slackWebhook = pm.environment.get("SLACK_WEBHOOK_URL"); pm.sendRequest({ url: slackWebhook, method: 'POST', header: { 'Content-Type': 'application/json' }, body: { mode: 'raw', raw: JSON.stringify({ text: `🚨 Tallyfy API Monitor Alert`, attachments: [{ color: "danger", fields: [{ title: "Failed Tests", value: pm.test.failures.map(f => f.name).join("\n"), short: false }, { title: "Environment", value: pm.environment.name, short: true }, { title: "Time", value: new Date().toISOString(), short: true }] }] }) } }); } ``` ## Performance optimization strategies ### Request optimization patterns ```javascript // Optimize requests for better performance const optimizationConfig = { // Reuse connections keepAlive: true, // Compress requests compression: 'gzip', // Optimal timeouts timeouts: { request: 30000, script: 5000, dns: 5000 }, // Rate limiting respect delays: { betweenRequests: 100, onRateLimit: 5000 } }; // Apply in pre-request script pm.request.timeout = optimizationConfig.timeouts.request; // Adaptive delay based on previous response const lastResponseTime = pm.environment.get("LAST_RESPONSE_TIME"); if (lastResponseTime > 2000) { // Slow API, increase delay pm.environment.set("REQUEST_DELAY", 500); } else { pm.environment.set("REQUEST_DELAY", 100); } ``` ### Memory management for large test suites ```javascript // Clean up variables after each iteration const cleanupKeys = [ "TEMP_PROCESS_ID", "TEMP_TASK_DATA", "CACHED_RESPONSE", "ITERATION_STATE" ]; cleanupKeys.forEach(key => { pm.environment.unset(key); }); // Memory-efficient data handling const largeDataSet = pm.response.json(); if (largeDataSet.length > 1000) { // Process in chunks to avoid memory issues const chunkSize = 100; for (let i = 0; i < largeDataSet.length; i += chunkSize) { const chunk = largeDataSet.slice(i, i + chunkSize); // Process chunk processDataChunk(chunk); } } ``` ## Next steps You've mastered advanced Postman patterns including: - ✅ Multi-environment testing with automated switching - ✅ CI/CD integration with Newman and GitHub Actions - ✅ Mock server strategies for E2E testing - ✅ Data-driven testing with CSV/JSON - ✅ Performance monitoring and optimization Continue with: - [Troubleshooting common issues](/products/pro/integrations/open-api/api-clients/postman/troubleshooting/) - [Collection organization best practices](/products/pro/integrations/open-api/api-clients/postman/collection-organization/) - [Webhook integration](/products/pro/integrations/webhooks/) - **[Authentication setup for Postman](https://tallyfy.com/products/pro/integrations/open-api/api-clients/postman/authentication-setup/)**: Tallyfy's API authentication in Postman requires using the password grant type with proper environment variables for credentials and the mandatory X-Tallyfy-Client header on every request while implementing automatic token refresh before the one-hour expiry to maintain uninterrupted API testing access. To use Tallyfy's API with Postman, configure OAuth authentication with your client credentials and implement the password grant type for user-context endpoints. Most Tallyfy endpoints require user context, making proper authentication setup essential for successful API testing. ## Why Tallyfy authentication has specific requirements Tallyfy's authentication has specific requirements that can trip you up if you're not aware. Here's what actually matters: - **Client credentials won't work for most endpoints** - They only provide application-level access - **Password grant is required** - User context is needed for most API operations - **The X-Tallyfy-Client header is mandatory** - Forget this and nothing works - **Tokens expire after 1 hour** - Plan for automatic refresh ## Setting up authentication step by step ## Authentication flow visualization This diagram shows the complete OAuth authentication lifecycle including initial setup, API usage, and automatic token refresh. [Diagram removed for brevity] **What to notice:** - **Step 1-3**: Initial password grant requires all four parameters (username, password, client_id, client_secret) to get your first tokens - **Step 6**: Every API call must include both the Bearer token AND the X-Tallyfy-Client header - missing either causes authentication failures - **Step 10-12**: Token refresh happens automatically before expiry using the refresh_token, preventing interruptions in your API testing ## The critical header everyone forgets Every single API request needs this header: ``` X-Tallyfy-Client: APIClient ``` Without it, you'll get mysterious 401 errors that make no sense. Add it to your collection's pre-request script: ```javascript pm.request.headers.add({ key: 'X-Tallyfy-Client', value: 'APIClient' }); // Also add the Authorization header const token = pm.environment.get("TALLYFY_ACCESS_TOKEN"); if (token) { pm.request.headers.add({ key: 'Authorization', value: `Bearer ${token}` }); } ``` ## Automatic token refresh Tokens expire after 1 hour. Here's a pre-request script that auto-refreshes: ```javascript const tokenExpiry = pm.environment.get("TALLYFY_TOKEN_EXPIRY"); const now = new Date().getTime(); // Check if token is expired or about to expire (5 min buffer) if (!tokenExpiry || now >= tokenExpiry - 300000) { const refreshToken = pm.environment.get("TALLYFY_REFRESH_TOKEN"); if (refreshToken) { pm.sendRequest({ url: pm.environment.get("TALLYFY_BASE_URL") + "/oauth/token", method: 'POST', header: { 'Content-Type': 'application/x-www-form-urlencoded' }, body: { mode: 'urlencoded', urlencoded: [ {key: 'grant_type', value: 'refresh_token'}, {key: 'refresh_token', value: refreshToken}, {key: 'client_id', value: pm.environment.get("TALLYFY_CLIENT_ID")}, {key: 'client_secret', value: pm.environment.get("TALLYFY_CLIENT_SECRET")} ] } }, (err, res) => { if (!err && res.code === 200) { const response = res.json(); pm.environment.set("TALLYFY_ACCESS_TOKEN", response.access_token); pm.environment.set("TALLYFY_REFRESH_TOKEN", response.refresh_token); const newExpiry = now + (response.expires_in * 1000); pm.environment.set("TALLYFY_TOKEN_EXPIRY", newExpiry); console.log("Token refreshed successfully"); } else { console.error("Token refresh failed - request a new token manually"); } }); } } ``` ## Understanding grant types Here's the truth about Tallyfy's OAuth grant types: | Grant Type | What It Does | When to Use | Common Mistake | |------------|--------------|-------------|----------------| | password | Provides full user context | Always for API testing | Not using this when you should | | client_credentials | Application-only access | System integrations only | Using this for user operations | | refresh_token | Get new access token | When token expires | Forgetting to store refresh token | **The bottom line**: Use password grant for Postman testing. Period. ## Security best practices ### Environment variables for sensitive data Never hardcode credentials. Always use environment variables: - Mark sensitive variables as "secret" in Postman - Use initial/current value distinction - Never commit environment files to version control ### Postman Vault for extra security For production credentials, use Postman's vault: ```javascript // Store in vault pm.vault.set("TALLYFY_CLIENT_SECRET", "your-secret"); // Retrieve from vault const secret = await pm.vault.get("TALLYFY_CLIENT_SECRET"); ``` ### Team sharing considerations When sharing collections: 1. Export collection without environment 2. Document required environment variables 3. Use placeholder values in examples 4. Add setup instructions to collection description ## Common authentication errors and fixes ### "401 Unauthenticated" - the usual suspects 1. **Missing X-Tallyfy-Client header** (most common cause) ``` X-Tallyfy-Client: APIClient ``` 2. **Expired token** - Tokens last exactly 1 hour - Implement auto-refresh or request new token 3. **Wrong grant type** - Use `password` not `client_credentials` - Client credentials only work for limited endpoints 4. **Typo in Bearer token** ``` Authorization: Bearer [token] // Exactly one space after Bearer ``` ### "400 Bad Request" on token endpoint Check your request body format: - Must be `x-www-form-urlencoded` not JSON - All parameters must be present - No extra spaces in values ### "Invalid client" error - Verify Client ID and Secret are correct - Check you're using the right environment - Ensure credentials match your organization ## Testing your authentication Create a simple test request: ``` GET {{TALLYFY_BASE_URL}}/organizations/{{TALLYFY_ORG_ID}}/me Headers: Authorization: Bearer {{TALLYFY_ACCESS_TOKEN}} X-Tallyfy-Client: APIClient ``` If this returns your user details, authentication is working correctly. ## Next steps With authentication sorted, you're ready to: - [Work with templates and processes](/products/pro/integrations/open-api/api-clients/postman/templates-processes/) - [Automate task operations](/products/pro/integrations/open-api/api-clients/postman/task-operations/) Remember: Good authentication setup saves hours of debugging later. Get it right once, and everything else just works. - **[Collection organization best practices](https://tallyfy.com/products/pro/integrations/open-api/api-clients/postman/collection-organization/)**: Organize Postman collections for Tallyfy's API by grouping requests by resource type using folders for workflows and implementing consistent naming conventions with bracket prefixes like [SETUP] [CORE] and [UTILS] to help team members quickly identify purpose and access levels while reducing errors and speeding up integration development. To organize Postman collections for Tallyfy's API effectively, group requests by resource type, use folders for workflows, and implement consistent naming conventions. Well-organized collections reduce errors and speed up Tallyfy integration development. ## Collection structure patterns ### Resource-based organization Postman experts recommend organizing by domain resources, following RESTful API patterns. Structure your collection to mirror Tallyfy's resources: ``` 📁 Tallyfy API Collection 📁 [SETUP] Authentication - Get Access Token (Password Grant) - Refresh Access Token - Test Authentication - Multi-User Token Manager 📁 [CORE] Templates (Checklists) - List All Templates - Get Template Details - Get Template with Prereqs - Search Templates by Category - Template Permissions Check 📁 [CORE] Processes (Runs) - Launch Process - Launch with Kick-off Data - Launch with Dynamic Assignees - List Active Processes - Get Process Details - Update Process Metadata - Archive Process - Bulk Process Operations 📁 [CORE] Tasks - List My Tasks - List Org Tasks (Filtered) - Get Task Details - Complete Task - Complete with Form Data - Bulk Complete Tasks - Add Task Comment - Reassign Task - Task Escalation 📁 [UTILS] Files - Upload File to Task - Upload Multiple Files - Download File - Get File Metadata - Delete File - File Type Validation 📁 [ADMIN] Members & Groups - List Organization Members - Get Member Details - Invite New Member - Update Member Role - Create Group - Assign Group to Task - Group Permissions 📁 [DEMO] Workflows (End-to-End) - Complete Onboarding Flow - Approval Process Demo - Document Review Cycle - Emergency Process Override 📁 [ADMIN] Reports & Analytics - Organization Settings - Export Process Data - Analytics Queries - Performance Metrics - Audit Trail Access ``` **Expert insight**: The bracket prefixes ([SETUP], [CORE], [UTILS], [ADMIN], [DEMO]) help team members quickly identify the purpose and access level required for each folder section. ### Workflow-based organization For process-specific collections: ``` 📁 HR Processes Collection 📁 Employee Onboarding 📂 Setup - Authenticate - Get Onboarding Template 📂 Launch - Create New Employee Process - Assign to HR Manager 📂 Day 1 Tasks - Complete Paperwork Task - Upload Documents - IT Equipment Request 📂 Week 1 Tasks - Training Assignments - Manager Check-in 📂 Verification - Check All Tasks Complete - Generate Report 📁 Performance Reviews ... 📁 Leave Requests ... ``` ## Naming conventions ### Request naming standards Consistent naming significantly reduces onboarding time for new team members. Use this proven pattern: **Format**: `[METHOD] - [Action] [Resource] [Context]` ``` ✅ Expert-level names: - POST - Launch Process from Template with Assignees - GET - List Active Tasks for Current User (Filtered) - PUT - Complete Task with Form Data and File Upload - DELETE - Archive Completed Process (Bulk Operation) - PATCH - Update Task Assignment by Workload - GET - Search Templates by Category and Permissions ❌ Beginner mistakes: - Test - New Request - API Call 1 - Process Stuff - Copy of Launch Process - Untitled Request ``` **Advanced naming patterns**: ``` // Environment-specific naming - [PROD] GET - List Templates - [STAGE] POST - Launch Test Process - [DEV] DELETE - Cleanup Test Data // User context naming - [ADMIN] PUT - Update Organization Settings - [USER] GET - List My Assigned Tasks - [GUEST] POST - Submit External Form // Workflow sequence naming - [1] POST - Authenticate User - [2] GET - Fetch Available Templates - [3] POST - Launch Selected Process - [4] PUT - Complete First Task - [5] GET - Verify Process Status ``` ### Variable naming standards Based on Postman enterprise best practices, establish clear variable hierarchies: ```javascript // Global variables (SCREAMING_SNAKE_CASE) - rarely used APP_VERSION API_SPECIFICATION_VERSION DEFAULT_TIMEOUT // Environment variables (UPPERCASE with prefix) TALLYFY_BASE_URL TALLYFY_ORG_ID TALLYFY_ACCESS_TOKEN TALLYFY_CLIENT_ID TALLYFY_RATE_LIMIT // Collection variables (PascalCase with context) CurrentProcessId ActiveTemplateId TestUserEmail DefaultAssigneeGroup BaselineResponseTime // Request-local variables (camelCase) const taskCount = 5; const processName = "Onboarding"; const iterationIndex = pm.info.iteration; // Temporary variables (prefix with TEMP_) TEMP_AUTH_STATE TEMP_UPLOAD_TOKEN TEMP_VALIDATION_RESULT // Debug variables (prefix with DEBUG_) DEBUG_REQUEST_COUNT DEBUG_ERROR_LOG DEBUG_PERFORMANCE_METRICS ``` **Variable scoping best practices**: ```javascript // Use appropriate scope for data lifecycle // Global: App-wide constants (rarely changes) pm.globals.set("API_VERSION", "v2"); // Environment: Environment-specific config pm.environment.set("TALLYFY_BASE_URL", "https://go.tallyfy.com/api"); // Collection: Shared across requests in collection pm.collectionVariables.set("CurrentSessionId", sessionId); // Local: Single request only pm.variables.set("tempCalculation", result); // Best practice: Clear temporary variables pm.test("Cleanup", () => { ["TEMP_AUTH_STATE", "TEMP_UPLOAD_TOKEN"].forEach(key => { pm.environment.unset(key); }); }); ``` ### Folder prefixes and organization Enterprise teams use standardized prefixes to indicate purpose and access levels: ``` 📁 [SETUP] - Authentication & Configuration 📁 [CORE] - Primary Business Operations 📁 [UTILS] - Helper Requests & Utilities 📁 [TEST] - Testing Scenarios & Validation 📁 [DEMO] - Example Workflows & Training 📁 [ADMIN] - Administrative Operations 📁 [DEBUG] - Debugging & Diagnostics 📁 [DEPRECATED] - Legacy Requests (Keep for Reference) ``` **Advanced folder organization patterns**: ``` // By API version 📁 [V1] Legacy API Endpoints 📁 [V2] Current API Endpoints 📁 [V3] Beta API Endpoints // By user role 📁 [ADMIN_ONLY] Administrative Functions 📁 [USER_STD] Standard User Operations 📁 [GUEST_ACCESS] External User Functions // By environment 📁 [PROD_SAFE] Production-Safe Operations 📁 [STAGE_TEST] Staging Test Operations 📁 [DEV_EXPERIMENTAL] Development Experiments // By workflow stage 📁 [01_SETUP] Initial Configuration 📁 [02_ONBOARD] User Onboarding Flow 📁 [03_OPERATE] Daily Operations 📁 [04_MAINTAIN] Maintenance Tasks 📁 [05_CLEANUP] Cleanup & Archival ``` **Folder ordering best practices**: ``` // Use numeric prefixes for logical ordering 📁 01-Authentication 📁 02-Templates 📁 03-Processes 📁 04-Tasks 📁 05-Files 📁 06-Admin 📁 99-Utilities // Or use emoji for visual distinction 📁 🔐 Authentication 📁 📋 Templates 📁 ⚙️ Processes 📁 ✅ Tasks 📁 📎 Files 📁 👥 Admin 📁 🛠️ Utilities ``` ## Documentation standards ### Collection description Based on enterprise team feedback, thorough documentation significantly reduces support requests: ```markdown # Tallyfy API Collection v2.1 ## 🎯 Overview This collection provides complete coverage of Tallyfy's REST API for workflow automation. Designed for developers, QA engineers, and integration specialists. ## 📋 Prerequisites - Tallyfy account with API access enabled - Client ID and Secret from Settings > Integrations > REST API - Basic understanding of OAuth 2.0 and REST APIs - Postman v10.0+ (for advanced scripting features) ## 🚀 Quick Start 1. **Import collection**: Use "Import" button and select this file 2. **Create environment**: - Name: "Tallyfy Production" (or "Staging") - Add required variables (see Variables section below) 3. **Run setup**: Execute "[SETUP] Get Access Token" request first 4. **Verify connection**: Run "[TEST] Authentication Check" 5. **Explore workflows**: Start with "[DEMO] Workflows" folder ## 🔧 Required Environment Variables | Variable | Description | Example | |----------|-------------|----------| | `TALLYFY_BASE_URL` | API base URL | `https://go.tallyfy.com/api` | | `TALLYFY_CLIENT_ID` | OAuth client ID | `3MVG9...` | | `TALLYFY_CLIENT_SECRET` | OAuth client secret | ⚠️ Store in vault | | `TALLYFY_USERNAME` | Your email | `you@company.com` | | `TALLYFY_PASSWORD` | Your password | ⚠️ Store in vault | | `TALLYFY_ORG_ID` | Organization ID | `org_abc123` | ## 🛡️ Security Best Practices - **Use Postman Vault** for sensitive data (passwords, secrets) - **Never commit** environment files with real credentials - **Rotate credentials** every 90 days - **Use separate** environments for prod/staging/dev ## ✨ Key Features - 🔄 Automatic token refresh (1-hour tokens) - 📊 Built-in performance monitoring - 🐛 Full error handling and logging - 📝 Request/response validation - 🔀 Bulk operation support - 🌐 Multi-environment support - 🧪 Data-driven testing capabilities ## 📚 Folder Structure Guide - **[SETUP]**: Authentication and configuration - **[CORE]**: Primary business operations (templates, processes, tasks) - **[UTILS]**: Helper requests and utilities - **[DEMO]**: Example workflows and training scenarios - **[ADMIN]**: Administrative operations (requires admin role) - **[TEST]**: Validation and testing requests ## 🔍 Debugging 1. **Enable console**: View → Show Postman Console 2. **Check debug variables**: Look for DEBUG_* variables in environment 3. **Review error log**: Check ERROR_LOG environment variable 4. **Performance metrics**: Check RESPONSE_METRICS for timing data ## 📊 Collection Metrics - **Total requests**: 47 - **Coverage**: Templates, Processes, Tasks, Files, Members, Admin - **Test coverage**: 100% of requests have validation scripts - **Last updated**: {{$timestamp}} - **Maintainer**: API Team ## 🆘 Support - **API Documentation**: [https://go.tallyfy.com/api/](https://go.tallyfy.com/api/) - **Status Page**: [https://status.tallyfy.com/](https://status.tallyfy.com/) - **Community Forum**: [https://community.postman.com/](https://community.postman.com/) - **Internal Support**: #api-support (Slack) - **Email Support**: support@tallyfy.com ## 📋 Common Issues & Solutions | Issue | Cause | Solution | |-------|-------|----------| | 401 Unauthorized | Missing X-Tallyfy-Client header | Add to pre-request script | | Token expired | >1 hour since last refresh | Run "Refresh Access Token" | | File upload fails | Manual Content-Type header | Remove Content-Type, use form-data | | Rate limit hit | >1000 requests/hour | Implement delays in bulk operations | ## 📈 Changelog - **v2.1**: Added bulk operations, improved error handling - **v2.0**: OAuth 2.0 migration, security enhancements - **v1.5**: Multi-environment support - **v1.0**: Initial release ``` ### Request documentation Enterprise teams document requests with this proven template: ```markdown ## Complete Task with Form Data ### 📝 Description Completes a task and submits any required form field data. This endpoint triggers workflow progression and notifications. ### 🎯 Use Cases - Approve/reject requests with comments - Submit completed work with evidence - Progress multi-step workflows - Capture structured data for reporting ### ✅ Prerequisites - Task must be assigned to authenticated user (or user has admin role) - Task must be in 'active' status - All required form fields must be provided - User must have completion permissions ### 📥 Request **Method**: `PUT` **Endpoint**: `/tasks/{taskId}/complete` **Content-Type**: `application/json` **Path Parameters**: - `taskId` (string, required): The task identifier **Request Body**: ```json { "captures": { "field_status": "Approved", // Select field "field_amount": 1500.00, // Number field "field_notes": "Approved per policy", // Text field "field_approved": true, // Boolean field "field_date": "2025-03-15" // Date field (YYYY-MM-DD) }, "comment": "Optional completion comment" // Optional } ``` ### 📤 Response **Success (200)**: ```json { "id": "task_123", "status": "completed", "completed_at": "2025-03-15T10:30:00Z", "completed_by": "user_456", "captures": { "field_status": "Approved", "field_amount": 1500.00, "field_notes": "Approved per policy" }, "next_tasks": ["task_789"] // Tasks created by completion } ``` ### ⚠️ Error Responses | Code | Reason | Solution | |------|--------|----------| | 400 | Invalid JSON format | Check request body syntax | | 401 | Authentication failed | Verify token and X-Tallyfy-Client header | | 403 | Permission denied | Task not assigned to you | | 404 | Task not found | Check task ID and organization | | 422 | Validation failed | Check required fields and data types | | 429 | Rate limit exceeded | Add delays between requests | ### 🧪 Test Script ```javascript // Validation tests included with request pm.test("Task completed successfully", () => { pm.expect(pm.response.code).to.equal(200); const response = pm.response.json(); pm.expect(response.status).to.equal("completed"); pm.expect(response.completed_at).to.exist; }); pm.test("Form data captured", () => { const response = pm.response.json(); pm.expect(response.captures).to.exist; pm.expect(response.captures.field_status).to.equal("Approved"); }); ``` ### 📊 Performance - **Typical response time**: 200-500ms - **Rate limit**: 1000 requests/hour - **Timeout**: 30 seconds ### 🔗 Related Endpoints - `GET /tasks/{taskId}` - Get task details - `POST /tasks/{taskId}/comments` - Add comment - `PUT /tasks/{taskId}/assign` - Reassign task ### 💡 Tips - Use dynamic field validation from task schema - Implement retry logic for network issues - Cache form field definitions to reduce API calls - Consider bulk completion for multiple tasks ``` ## Environment management ### Environment hierarchy Set up multiple environments: ```javascript // Production (Default) { "TALLYFY_BASE_URL": "https://go.tallyfy.com/api", "TALLYFY_ORG_ID": "org_prod_123", "LOG_LEVEL": "ERROR" } // Staging { "TALLYFY_BASE_URL": "https://go.tallyfy.com/api", "TALLYFY_ORG_ID": "org_stage_456", "LOG_LEVEL": "INFO" } // Development { "TALLYFY_BASE_URL": "https://go.tallyfy.com/api", "TALLYFY_ORG_ID": "org_dev_789", "LOG_LEVEL": "DEBUG", "USE_MOCK": "false" } ``` ### Variable scoping Use appropriate scope for variables: ```javascript // Global variables - Rarely used pm.globals.set("APP_VERSION", "1.0.0"); // Collection variables - Shared across requests pm.collectionVariables.set("DefaultTimeout", 5000); // Environment variables - Environment-specific pm.environment.set("TALLYFY_ORG_ID", "org_123"); // Local variables - Single request only pm.variables.set("tempValue", "abc"); ``` ## Pre-request scripts ### Collection-level script Add to collection for all requests: ```javascript // Auto-add required headers if (!pm.request.headers.has("X-Tallyfy-Client")) { pm.request.headers.add({ key: "X-Tallyfy-Client", value: "APIClient" }); } // Add auth header if token exists const token = pm.environment.get("TALLYFY_ACCESS_TOKEN"); if (token && !pm.request.headers.has("Authorization")) { pm.request.headers.add({ key: "Authorization", value: `Bearer ${token}` }); } // Performance tracking pm.variables.set("requestStartTime", Date.now()); ``` ### Folder-level scripts Add specific behavior to folders: ```javascript // For "Files" folder - add multipart handling if (pm.request.body && pm.request.body.mode === 'formdata') { console.log("File upload request detected"); // Add file-specific handling } // For "Admin" folder - add extra logging console.log("Admin operation:", pm.request.name); pm.environment.set("ADMIN_ACTION_LOG", pm.request.name); ``` ## Test organization ### Shared test functions Create reusable test utilities: ```javascript // In collection Tests tab pm.collectionVariables.set("testUtils", { // Check successful response expectSuccess: function(responseCode = 200) { pm.test(`Status code is ${responseCode}`, () => { pm.expect(pm.response.code).to.equal(responseCode); }); pm.test("Response time is acceptable", () => { pm.expect(pm.response.responseTime).to.be.below(1000); }); }, // Validate response structure expectFields: function(fields) { pm.test("Response has required fields", () => { const json = pm.response.json(); fields.forEach(field => { pm.expect(json).to.have.property(field); }); }); }, // Save ID for chaining saveId: function(idField, variableName) { const id = pm.response.json()[idField]; if (id) { pm.collectionVariables.set(variableName, id); console.log(`Saved ${variableName}: ${id}`); } } }); // Usage in request tests: const utils = pm.collectionVariables.get("testUtils"); utils.expectSuccess(201); utils.expectFields(['id', 'name', 'status']); utils.saveId('id', 'lastProcessId'); ``` ## Version control ### Exporting for Git Best practices for version control: 1. **Export settings**: - Export collection as v2.1 format - Include collection variables - Exclude environment values 2. **Directory structure**: ``` postman/ collections/ tallyfy-api-v1.json tallyfy-workflows.json environments/ production.template.json staging.template.json schemas/ openapi-spec.json scripts/ pre-request-global.js test-utils.js ``` 3. **Environment templates**: ```json { "name": "Tallyfy Production", "values": [ { "key": "TALLYFY_CLIENT_ID", "value": "REPLACE_ME", "type": "secret" }, { "key": "TALLYFY_BASE_URL", "value": "https://go.tallyfy.com/api", "type": "default" } ] } ``` ### Change tracking Add version info to collection: ```javascript // In collection description or pre-request const collectionInfo = { version: "2.1.0", lastUpdated: new Date().toISOString().split('T')[0], author: "API Team", changelog: [ "2.1.0 - Added bulk operations", "2.0.0 - Migrated to OAuth", "1.0.0 - Initial release" ] }; pm.collectionVariables.set("COLLECTION_INFO", collectionInfo); ``` ## Sharing and collaboration ### Team workspace setup Organize for team use: 1. **Workspace structure**: ``` Tallyfy API Workspace/ Official Collections/ - Tallyfy API v2 - Tallyfy Webhooks Team Collections/ - HR Workflows - Finance Processes Personal/ - [User] Test Collection ``` 2. **Permissions**: - Official: View only for most - Team: Edit for department - Personal: Private drafts 3. **Forking strategy**: - Fork official collections for experiments - Submit pull requests for improvements - Maintain clear fork naming ### Documentation for sharing Include a README in your collection: ```markdown ## Quick Start 1. Fork this collection to your workspace 2. Create environment from template 3. Add your credentials (see Setup Guide) 4. Run "Test Authentication" to verify 5. Explore example workflows in /Demos ## Common Issues - 401 Errors: Check X-Tallyfy-Client header - Rate limits: See /Utils/Check Rate Limit - File uploads: Must use form-data ## Contributing 1. Fork the collection 2. Make changes in your fork 3. Test thoroughly 4. Submit pull request with description ``` ## Maintenance practices ### Regular cleanup Monthly maintenance tasks: ```javascript // Find unused variables const env = pm.environment.toObject(); const unused = []; Object.keys(env).forEach(key => { // Search collection for variable usage const used = pm.collectionVariables.get(`${key}_USED`); if (!used) { unused.push(key); } }); console.log("Potentially unused variables:", unused); ``` ### Performance optimization Keep collections fast: 1. **Minimize pre-request scripts** - Only essential logic 2. **Async operations** - Use promises for parallel requests 3. **Conditional tests** - Skip tests when not needed 4. **Archive old requests** - Move to separate collection ## Advanced organization techniques ### Collection inheritance and DRY principles Postman experts follow "Don't Repeat Yourself" principles: ```javascript // Collection-level pre-request script (applies to all requests) const baseConfig = { timeout: 30000, retries: 3, rateLimit: { requestsPerHour: 1000, minDelay: 100 } }; // Auto-add required headers if (!pm.request.headers.has("X-Tallyfy-Client")) { pm.request.headers.add({ key: "X-Tallyfy-Client", value: "APIClient" }); } // Auto-refresh token if needed const tokenExpiry = pm.environment.get("TALLYFY_TOKEN_EXPIRY"); if (tokenExpiry && Date.now() >= tokenExpiry - 300000) { // 5 min buffer console.log("Token refresh needed - consider running refresh request"); } // Apply base configuration pm.request.timeout = baseConfig.timeout; ``` ### Multi-level folder structure Utilize Postman's deep nesting capabilities: ``` 📁 Tallyfy API Collection 📁 [CORE] Templates 📁 Template CRUD - Create Template - Read Template - Update Template - Delete Template 📁 Template Workflows - Launch Process - Clone Template - Export Template 📁 Template Admin - Set Permissions - Archive Template - Audit Template Changes 📁 [CORE] Processes 📁 Process Lifecycle 📁 Creation - Launch from Template - Launch with Data - Bulk Launch 📁 Management - Update Process - Add Participants - Change Deadlines 📁 Completion - Archive Process - Export Data - Generate Reports ``` ### Collection-level configuration ```javascript // Collection variables for shared configuration pm.collectionVariables.set("API_VERSION", "v2"); pm.collectionVariables.set("DEFAULT_TIMEOUT", 30000); pm.collectionVariables.set("MAX_RETRIES", 3); pm.collectionVariables.set("DEBUG_MODE", "INFO"); // Shared utilities const utils = { formatDate: (date) => date.toISOString().split('T')[0], generateId: () => pm.variables.replaceIn('{{$randomUUID}}'), logError: (context, error) => { const errorLog = JSON.parse(pm.environment.get("ERROR_LOG") || '[]'); errorLog.push({ timestamp: new Date().toISOString(), context: context, error: error, request: pm.request.url.toString() }); pm.environment.set("ERROR_LOG", JSON.stringify(errorLog)); } }; pm.collectionVariables.set("UTILS", JSON.stringify(utils)); ``` ### Request dependencies and sequencing ```javascript // Dependency tracking system const dependencies = { "Complete Task": ["Get Task Details", "Authenticate"], "Launch Process": ["Get Template", "Authenticate"], "Upload File": ["Complete Task", "Authenticate"] }; // Auto-validate dependencies const currentRequest = pm.info.requestName; const requiredDeps = dependencies[currentRequest] || []; requiredDeps.forEach(dep => { const depCompleted = pm.environment.get(`DEP_${dep.replace(/\s+/g, '_').toUpperCase()}`); if (!depCompleted) { console.warn(`⚠️ Dependency not met: ${dep}`); } }); // Mark current request as completed pm.test("Mark dependency completed", () => { if (pm.response.code < 400) { pm.environment.set(`DEP_${currentRequest.replace(/\s+/g, '_').toUpperCase()}`, true); } }); ``` ### Performance and maintenance ```javascript // Collection health monitoring const collectionHealth = { totalRequests: pm.info.requestId, averageResponseTime: pm.environment.get("AVERAGE_RESPONSE_TIME") || 0, errorRate: pm.environment.get("ERROR_RATE") || 0, lastMaintenance: pm.environment.get("LAST_MAINTENANCE") || "Never" }; // Alert on performance degradation if (collectionHealth.averageResponseTime > 2000) { console.warn("⚠️ Collection performance degraded - review slow endpoints"); } // Auto-cleanup old data const cleanupInterval = 7 * 24 * 60 * 60 * 1000; // 7 days const lastCleanup = pm.environment.get("LAST_CLEANUP") || 0; if (Date.now() - lastCleanup > cleanupInterval) { // Clean up old logs and temporary data ["ERROR_LOG", "RESPONSE_METRICS", "DEBUG_SESSION_DATA"].forEach(key => { const data = JSON.parse(pm.environment.get(key) || '[]'); if (data.length > 100) { pm.environment.set(key, JSON.stringify(data.slice(-50))); } }); pm.environment.set("LAST_CLEANUP", Date.now()); console.log("🧹 Performed automated cleanup"); } ``` Remember: A well-organized collection is a joy to use and maintain. These enterprise patterns reduce onboarding time, improve reliability, and scale with your team's growth. Invest time in structure - it pays dividends over months and years. - **[Task operations and automation](https://tallyfy.com/products/pro/integrations/open-api/api-clients/postman/task-operations/)**: Tallyfy's task management API enables you to list filter and complete work items within running processes while handling form fields file attachments assignments and automated workflows through various endpoints and patterns including bulk operations dynamic assignment based on workload and conditional task completion. To work with tasks in Postman, use the Tallyfy tasks endpoints to list, complete, and update task data including form fields and file attachments. Tasks are the individual work items within running processes that users complete. ## Understanding task structure In Tallyfy's API: - **Tasks** = Individual work items in a running process - **Captures** = Form field data within tasks - **Assignments** = Who's responsible for completing the task ## Listing tasks ### Get your assigned tasks ``` GET {{TALLYFY_BASE_URL}}/organizations/{{TALLYFY_ORG_ID}}/me/tasks Headers: Authorization: Bearer {{TALLYFY_ACCESS_TOKEN}} X-Tallyfy-Client: APIClient Query parameters: - status: active, completed - limit: 100 - offset: 0 ``` ### Get all tasks in a process ``` GET {{TALLYFY_BASE_URL}}/runs/{{PROCESS_ID}}/tasks ``` ### Filter tasks by various criteria ```javascript // Advanced filtering in Tests tab const tasks = pm.response.json().data; // Overdue tasks const overdueTasks = tasks.filter(t => t.deadline && new Date(t.deadline) < new Date() && t.status === 'active' ); // Tasks by specific assignee const userTasks = tasks.filter(t => t.assignees.some(a => a.email === 'john@company.com') ); // High priority tasks (based on process name or custom logic) const urgentTasks = tasks.filter(t => t.run_name.includes('URGENT') || t.run_name.includes('Priority') ); console.log(`Found ${overdueTasks.length} overdue tasks`); ``` ## Completing tasks ### Simple task completion ``` PUT {{TALLYFY_BASE_URL}}/tasks/{{TASK_ID}}/complete Headers: Authorization: Bearer {{TALLYFY_ACCESS_TOKEN}} X-Tallyfy-Client: APIClient ``` ### Complete with form data Most tasks have form fields that need values: ``` PUT {{TALLYFY_BASE_URL}}/tasks/{{TASK_ID}}/complete Body: { "captures": { "field_abc123": "Approved", "field_def456": 42.50, "field_ghi789": "Task completed successfully with no issues", "field_jkl012": true } } ``` ### Bulk task completion Complete multiple tasks efficiently: ```javascript const taskIds = ["task_123", "task_456", "task_789"]; const results = []; // Function to complete a single task function completeTask(taskId, captures = {}) { return new Promise((resolve, reject) => { pm.sendRequest({ url: `${pm.environment.get("TALLYFY_BASE_URL")}/tasks/${taskId}/complete`, method: 'PUT', header: { 'Authorization': `Bearer ${pm.environment.get("TALLYFY_ACCESS_TOKEN")}`, 'X-Tallyfy-Client': 'APIClient', 'Content-Type': 'application/json' }, body: { mode: 'raw', raw: JSON.stringify({ captures }) } }, (err, res) => { if (err) { reject(err); } else { resolve({ taskId, status: res.code }); } }); }); } // Complete tasks with delay to avoid rate limits async function completeTasks() { for (let i = 0; i < taskIds.length; i++) { try { const result = await completeTask(taskIds[i], { field_status: "Completed via API", field_date: new Date().toISOString() }); results.push(result); console.log(`Completed task ${i + 1} of ${taskIds.length}`); // Add delay between requests if (i < taskIds.length - 1) { await new Promise(resolve => setTimeout(resolve, 200)); } } catch (error) { console.error(`Failed to complete task ${taskIds[i]}:`, error); } } console.log('Bulk completion results:', results); } completeTasks(); ``` ## File attachments ### Upload file to task File uploads to Tallyfy require special handling in Postman. Here's the expert approach: **Critical insights from Postman experts**: - **Never set Content-Type manually**: Postman automatically sets `multipart/form-data` with proper boundary fields. Manual setting causes "Missing start boundary" errors - **Boundary field importance**: The boundary separates form parts - Postman generates cryptographically secure boundaries automatically - **File size considerations**: Individual files can't exceed 5MB for shared team collections - **Variable file paths**: Use environment variables for dynamic file selection: ```javascript // In pre-request script const filePath = pm.environment.get("UPLOAD_FILE_PATH"); pm.request.body.formdata.add({ key: "file", src: filePath, type: "file" }); ``` **Advanced file upload patterns**: ```javascript // Dynamic file selection based on task type const taskType = pm.environment.get("CURRENT_TASK_TYPE"); const fileMapping = { "approval": "approval_document.pdf", "review": "review_checklist.xlsx", "signature": "contract_template.docx" }; const fileName = fileMapping[taskType] || "default_file.txt"; pm.environment.set("UPLOAD_FILENAME", fileName); ``` **Common mistake**: Using raw JSON body instead of form-data. Files must use multipart/form-data with proper boundary handling. ### Download file from task ``` GET {{TALLYFY_BASE_URL}}/files/{{FILE_ID}}/download Headers: Authorization: Bearer {{TALLYFY_ACCESS_TOKEN}} X-Tallyfy-Client: APIClient ``` Save response using Postman's "Save Response" → "Save to a file" option. ## Task assignment patterns ### Reassign task ``` PUT {{TALLYFY_BASE_URL}}/tasks/{{TASK_ID}} Body: { "assignees": ["member_123", "member_456"] } ``` ### Dynamic assignment based on workload Assign to least busy team member: ```javascript // First, get all team members and their task counts async function assignToLeastBusy(taskId) { // Get all members const membersResponse = await pm.sendRequest({ url: `${pm.environment.get("TALLYFY_BASE_URL")}/organizations/${pm.environment.get("TALLYFY_ORG_ID")}/members`, method: 'GET', header: { 'Authorization': `Bearer ${pm.environment.get("TALLYFY_ACCESS_TOKEN")}`, 'X-Tallyfy-Client': 'APIClient' } }); const members = membersResponse.json().data; // Get task counts for each member const taskCounts = await Promise.all(members.map(async (member) => { const tasksResponse = await pm.sendRequest({ url: `${pm.environment.get("TALLYFY_BASE_URL")}/organizations/${pm.environment.get("TALLYFY_ORG_ID")}/members/${member.id}/tasks?status=active`, method: 'GET', header: { 'Authorization': `Bearer ${pm.environment.get("TALLYFY_ACCESS_TOKEN")}`, 'X-Tallyfy-Client': 'APIClient' } }); return { memberId: member.id, name: member.name, taskCount: tasksResponse.json().data.length }; })); // Find member with least tasks const leastBusy = taskCounts.reduce((prev, current) => prev.taskCount < current.taskCount ? prev : current ); console.log(`Assigning to ${leastBusy.name} (${leastBusy.taskCount} active tasks)`); // Assign the task return pm.sendRequest({ url: `${pm.environment.get("TALLYFY_BASE_URL")}/tasks/${taskId}`, method: 'PUT', header: { 'Authorization': `Bearer ${pm.environment.get("TALLYFY_ACCESS_TOKEN")}`, 'X-Tallyfy-Client': 'APIClient', 'Content-Type': 'application/json' }, body: { mode: 'raw', raw: JSON.stringify({ assignees: [leastBusy.memberId] }) } }); } ``` ## Task automation patterns ### Auto-complete approval tasks Automatically approve tasks based on conditions: ```javascript // Check task data and auto-approve if conditions met const task = pm.response.json(); if (task.name.includes("Auto-Approval") && task.run_name.includes("Low Risk")) { pm.sendRequest({ url: `${pm.environment.get("TALLYFY_BASE_URL")}/tasks/${task.id}/complete`, method: 'PUT', header: { 'Authorization': `Bearer ${pm.environment.get("TALLYFY_ACCESS_TOKEN")}`, 'X-Tallyfy-Client': 'APIClient', 'Content-Type': 'application/json' }, body: { mode: 'raw', raw: JSON.stringify({ captures: { field_approval: "Auto-approved", field_notes: "Automatically approved based on low risk criteria", field_timestamp: new Date().toISOString() } }) } }, (err, res) => { if (!err) { console.log("Task auto-approved successfully"); } }); } ``` ### Task escalation for overdue items Find and escalate overdue tasks: ```javascript // Get all active tasks const tasks = pm.response.json().data; const now = new Date(); const overdueTasks = tasks.filter(t => { if (!t.deadline || t.status !== 'active') return false; return new Date(t.deadline) < now; }); // Escalate each overdue task overdueTasks.forEach(task => { const hoursOverdue = Math.floor((now - new Date(task.deadline)) / (1000 * 60 * 60)); // Add comment about escalation pm.sendRequest({ url: `${pm.environment.get("TALLYFY_BASE_URL")}/tasks/${task.id}/comments`, method: 'POST', header: { 'Authorization': `Bearer ${pm.environment.get("TALLYFY_ACCESS_TOKEN")}`, 'X-Tallyfy-Client': 'APIClient', 'Content-Type': 'application/json' }, body: { mode: 'raw', raw: JSON.stringify({ content: `⚠️ ESCALATION: This task is ${hoursOverdue} hours overdue. Manager notified.` }) } }); // Could also reassign to manager or send notifications }); ``` ## Working with task comments ### Add comment to task ``` POST {{TALLYFY_BASE_URL}}/tasks/{{TASK_ID}}/comments Body: { "content": "Please review the attached documents before approving." } ``` ### Get task activity feed ``` GET {{TALLYFY_BASE_URL}}/tasks/{{TASK_ID}}/comments ``` ## Common task patterns ### Conditional task completion Complete tasks differently based on previous task data: ```javascript // Get process data first const process = pm.response.json(); // Find specific task data const approvalTask = process.tasks.find(t => t.name.includes("Manager Approval")); const approvalStatus = approvalTask?.captures?.field_approval_status; // Complete next task based on approval const nextTask = process.tasks.find(t => t.name.includes("Next Step") && t.status === 'active'); if (nextTask) { const captures = {}; if (approvalStatus === "Approved") { captures.field_action = "Proceed"; captures.field_notes = "Approved by manager"; } else { captures.field_action = "Revise"; captures.field_notes = "Requires revision per manager feedback"; } // Complete with appropriate data pm.sendRequest({ url: `${pm.environment.get("TALLYFY_BASE_URL")}/tasks/${nextTask.id}/complete`, method: 'PUT', header: { 'Authorization': `Bearer ${pm.environment.get("TALLYFY_ACCESS_TOKEN")}`, 'X-Tallyfy-Client': 'APIClient', 'Content-Type': 'application/json' }, body: { mode: 'raw', raw: JSON.stringify({ captures }) } }); } ``` ## Troubleshooting task operations ### "Cannot complete task" errors Common causes: - Task already completed - Not assigned to you - Required fields missing - Previous dependencies not complete ### File upload issues - Maximum file size: 25MB typically - Supported formats: Most common formats - Use form-data, not JSON - Include field_id if required ### Form field validation Tallyfy's form validation follows strict patterns. Here's what actually works: **Data type matching**: ```javascript // Common validation patterns const fieldValidation = { // String fields - any text "field_notes": "Any text value", // Number fields - must be numeric, not string "field_amount": 1500.50, // ✅ Correct "field_count": "25", // ❌ Wrong - string // Boolean fields - actual boolean "field_approved": true, // ✅ Correct "field_complete": "true", // ❌ Wrong - string // Date fields - ISO format "field_deadline": "2025-03-15", // ✅ Correct "field_due_date": "March 15, 2025", // ❌ Wrong "field_timestamp": "2025-03-15T10:30:00Z" // ✅ Also correct }; ``` **Select field validation**: ```javascript // Get valid options first const task = pm.response.json(); const priorityField = task.fields.find(f => f.id === "field_priority"); console.log("Valid options:", priorityField.options); // Then use exact match const captures = { "field_priority": "High" // Must match exactly }; ``` **Advanced validation script**: ```javascript // Pre-request validation const captures = JSON.parse(pm.request.body.raw).captures; const validationErrors = []; // Type checking Object.entries(captures).forEach(([fieldId, value]) => { if (fieldId.includes("amount") && typeof value !== "number") { validationErrors.push(`${fieldId} must be numeric, got ${typeof value}`); } if (fieldId.includes("approved") && typeof value !== "boolean") { validationErrors.push(`${fieldId} must be boolean, got ${typeof value}`); } }); if (validationErrors.length > 0) { console.error("Validation errors:", validationErrors); throw new Error("Form validation failed"); } ``` **Required field detection**: ```javascript // Auto-detect required fields from task schema const task = pm.response.json(); const requiredFields = task.fields .filter(f => f.required) .map(f => f.id); console.log("Required fields:", requiredFields); // Validate all required fields are present const captures = pm.variables.get("taskCaptures"); const missingRequired = requiredFields.filter(fieldId => !captures.hasOwnProperty(fieldId) || captures[fieldId] === null ); if (missingRequired.length > 0) { console.error("Missing required fields:", missingRequired); } ``` ## Next steps With task automation mastered: - [Explore advanced patterns](/products/pro/integrations/open-api/api-clients/postman/advanced-patterns/) - **[Working with templates and processes](https://tallyfy.com/products/pro/integrations/open-api/api-clients/postman/templates-processes/)**: Launching Tallyfy processes from templates in Postman requires using template IDs with kick-off form data in request bodies while understanding the API terminology difference where templates are called checklists and processes are called runs. To launch Tallyfy processes from templates in Postman, use the template ID with kick-off form data in the request body. The API accepts preruns for form fields and member assignments for process participants. ## Understanding templates vs processes Quick refresher on Tallyfy terminology: - **Templates** = Blueprints that define your workflow (API calls them "checklists") - **Processes** = Running instances of templates (API calls them "runs") - **Kick-off forms** = Data collection before launching (API calls them "preruns") This naming difference catches everyone. Just remember: Template → Process in Tallyfy UI equals Checklist → Run in API. ## Template to process launch flow This diagram shows the complete API flow from listing templates to launching and managing processes. [Diagram removed for brevity] **What to notice:** - **Step 3**: Templates are selected dynamically based on business rules (purchase amount thresholds determine approval levels) - **Step 5**: Kick-off form data (`preruns`) is validated before creating the process instance - **Step 8**: Process details include the unique process ID needed for subsequent operations ## Listing available templates First, see what templates you can launch: ``` GET {{TALLYFY_BASE_URL}}/organizations/{{TALLYFY_ORG_ID}}/checklists Headers: Authorization: Bearer {{TALLYFY_ACCESS_TOKEN}} X-Tallyfy-Client: APIClient ``` Response includes: ```json { "data": [ { "id": "checklist_abc123", "name": "Employee Onboarding", "description": "Standard process for new hires", "is_public": false, "steps_count": 12 } ] } ``` **Pro tip**: Save template IDs as environment variables for easy reuse. ## Launching a process ### Basic launch (no kick-off form) ``` POST {{TALLYFY_BASE_URL}}/organizations/{{TALLYFY_ORG_ID}}/checklists/{{TEMPLATE_ID}}/launch Headers: Authorization: Bearer {{TALLYFY_ACCESS_TOKEN}} X-Tallyfy-Client: APIClient Content-Type: application/json Body: { "name": "Onboarding - Jane Smith", "deadline_date": "2025-02-15" } ``` ### Launch with kick-off form data Most templates have kick-off forms. Here's how to pre-fill them: ```json { "name": "Purchase Request - MacBook Pro", "preruns": { "field_abc123": "John Smith", "field_def456": 2499.99, "field_ghi789": "Engineering team needs upgraded hardware", "field_jkl012": ["Option A", "Option B"] // Multi-select field }, "deadline_date": "2025-02-20" } ``` ### Finding field IDs Three ways to find kick-off form field IDs: 1. **Chrome DevTools method** (easiest): - Launch process manually in Tallyfy - Open Network tab - Look for the launch request - Copy field IDs from payload 2. **API exploration**: ``` GET {{TALLYFY_BASE_URL}}/checklists/{{TEMPLATE_ID}} ``` Look for `prerun_fields` in response 3. **Postman console**: - Enable Postman console (View → Show Postman Console) - Make requests and inspect full responses ## Advanced launch patterns ### Launch with specific assignees Assign members during launch: ```json { "name": "Q1 Budget Review", "members": { "member_123": ["step_1", "step_3", "step_5"], "member_456": ["step_2", "step_4"], "member_789": ["step_6", "step_7", "step_8"] } } ``` ### Conditional launch based on data Use pre-request scripts for dynamic launches: ```javascript // Determine template based on request amount const amount = pm.variables.get("purchase_amount"); let templateId; if (amount < 1000) { templateId = "template_simple"; } else if (amount < 10000) { templateId = "template_manager_approval"; } else { templateId = "template_executive_approval"; } pm.variables.set("DYNAMIC_TEMPLATE_ID", templateId); // Set deadline based on priority const priority = pm.variables.get("priority"); const deadline = new Date(); if (priority === "urgent") { deadline.setDate(deadline.getDate() + 1); } else { deadline.setDate(deadline.getDate() + 7); } pm.variables.set("DEADLINE", deadline.toISOString().split('T')[0]); ``` ### Bulk process launching Launch multiple processes efficiently: ```javascript const employees = [ { name: "Alice Johnson", dept: "Engineering", start: "2025-02-01" }, { name: "Bob Smith", dept: "Sales", start: "2025-02-05" }, { name: "Carol White", dept: "Marketing", start: "2025-02-10" } ]; employees.forEach((emp, index) => { setTimeout(() => { pm.sendRequest({ url: `${pm.environment.get("TALLYFY_BASE_URL")}/organizations/${pm.environment.get("TALLYFY_ORG_ID")}/checklists/${pm.environment.get("ONBOARDING_TEMPLATE_ID")}/launch`, method: 'POST', header: { 'Authorization': `Bearer ${pm.environment.get("TALLYFY_ACCESS_TOKEN")}`, 'X-Tallyfy-Client': 'APIClient', 'Content-Type': 'application/json' }, body: { mode: 'raw', raw: JSON.stringify({ name: `Onboarding - ${emp.name}`, preruns: { field_name: emp.name, field_dept: emp.dept, field_start: emp.start } }) } }, (err, res) => { if (!err) { console.log(`Launched process for ${emp.name}`); } }); }, index * 200); // 200ms delay between launches }); ``` ## Managing running processes ### List active processes ``` GET {{TALLYFY_BASE_URL}}/organizations/{{TALLYFY_ORG_ID}}/runs?status=active Query parameters: - status: active, completed, archived - updated_after: 2025-01-01T00:00:00Z - limit: 50 - offset: 0 ``` ### Get process details ``` GET {{TALLYFY_BASE_URL}}/runs/{{PROCESS_ID}} ``` Returns complete process info including: - Current status of all tasks - Assigned members - Form field values - Comments and activity ### Update process metadata ``` PUT {{TALLYFY_BASE_URL}}/runs/{{PROCESS_ID}} Body: { "name": "Updated Process Name", "deadline_date": "2025-03-01" } ``` ### Archive completed processes ``` PUT {{TALLYFY_BASE_URL}}/runs/{{PROCESS_ID}}/archive ``` ## Process monitoring patterns ### Find stuck processes Identify processes that haven't moved in X days: ```javascript // In Tests tab after listing processes const processes = pm.response.json().data; const stuckThreshold = 3; // days const stuckProcesses = processes.filter(p => { const lastUpdate = new Date(p.updated_at); const daysSinceUpdate = (Date.now() - lastUpdate) / (1000 * 60 * 60 * 24); return daysSinceUpdate > stuckThreshold && p.status === 'active'; }); if (stuckProcesses.length > 0) { console.log(`Found ${stuckProcesses.length} stuck processes:`); stuckProcesses.forEach(p => { console.log(`- ${p.name} (ID: ${p.id})`); }); // Save for further action pm.environment.set("STUCK_PROCESSES", JSON.stringify(stuckProcesses)); } ``` ### Process completion tracking Track completion rates by template: ```javascript // After getting all processes const processes = pm.response.json().data; const stats = {}; processes.forEach(p => { const templateId = p.checklist_id; if (!stats[templateId]) { stats[templateId] = { total: 0, completed: 0 }; } stats[templateId].total++; if (p.status === 'completed') { stats[templateId].completed++; } }); Object.entries(stats).forEach(([templateId, data]) => { const rate = (data.completed / data.total * 100).toFixed(1); console.log(`Template ${templateId}: ${rate}% completion rate`); }); ``` ## Common pitfalls and solutions ### "Template not found" errors - Verify template ID is correct - Check template isn't archived - Ensure you have permission to launch ### Kick-off form validation failures Common issues: - Required fields missing - Wrong data type (string vs number) - Invalid option for select fields Debug by getting template details first to see field requirements. ### Process launch limits Tallyfy may limit concurrent launches. If bulk launching: - Add delays between requests (100-500ms) - Batch in groups of 10-20 - Monitor for 429 rate limit errors ## Next steps Now that you can launch and manage processes: - [Automate task operations](/products/pro/integrations/open-api/api-clients/postman/task-operations/) - [Set up webhooks](/products/pro/integrations/webhooks/) for real-time updates - **[Troubleshooting common issues](https://tallyfy.com/products/pro/integrations/open-api/api-clients/postman/troubleshooting/)**: Fixing Postman errors with Tallyfy's API requires checking the X-Tallyfy-Client header first then verifying the authentication grant type is password (not client_credentials) and ensuring tokens haven't expired since these three issues cause most API failures. To fix Postman errors with Tallyfy's API, check the X-Tallyfy-Client header first, verify your authentication grant type is password not client_credentials, and ensure tokens haven't expired. These three issues cause the majority of Tallyfy API failures. ## Authentication errors ### 401 Unauthorized - the complete diagnostic approach Postman community experts have identified these patterns from thousands of support cases: 1. **Missing X-Tallyfy-Client header** (most common) ``` X-Tallyfy-Client: APIClient ``` Every single request needs this. No exceptions. **Expert insight**: This custom header prevents unauthorized API usage and helps Tallyfy track client types. Unlike standard OAuth implementations, many SaaS APIs like Tallyfy use custom headers for additional security layers. 2. **Wrong grant type** (very common) - You used: `grant_type=client_credentials` - You need: `grant_type=password` - Client credentials only work for system-level operations **Why this happens**: Developers assume `client_credentials` should work everywhere because it's "cleaner" - but OAuth 2.0 spec correctly separates machine-to-machine vs user-context operations. 3. **Expired token** (common) - Tokens last exactly 3600 seconds (1 hour) - Check token age: `pm.environment.get("TALLYFY_TOKEN_EXPIRY")` - Implement auto-refresh (see Authentication Setup guide) **Debugging script**: ```javascript // Advanced token expiry checker const tokenExpiry = pm.environment.get("TALLYFY_TOKEN_EXPIRY"); const tokenIssued = pm.environment.get("TALLYFY_TOKEN_ISSUED"); const now = Date.now(); if (tokenExpiry) { const timeLeft = tokenExpiry - now; const totalLife = tokenExpiry - tokenIssued; const percentUsed = ((totalLife - timeLeft) / totalLife * 100).toFixed(1); console.log(`Token status: ${percentUsed}% used, ${Math.round(timeLeft/1000/60)} minutes remaining`); if (timeLeft < 0) { console.error("Token expired!"); } else if (timeLeft < 300000) { // 5 minutes console.warn("Token expires soon, consider refreshing"); } } ``` 4. **Bearer token format** (less common) ``` // Wrong formats: Authorization: Bearer[token] // No space Authorization: Bearer [token] // Double space Authorization: [token] // Missing Bearer Authorization: bearer [token] // Lowercase // Correct (exactly one space): Authorization: Bearer [token] ``` **Advanced debugging**: The Authorization header is case-sensitive and space-sensitive. Many developers copy-paste tokens and accidentally include extra whitespace. ### Multiple user credentials debugging **Expert pattern**: Support teams often switch between different user accounts and API keys. Here's how to handle this cleanly: ```javascript // Multi-user credential manager const userProfiles = { "admin": { clientId: pm.vault.get("ADMIN_CLIENT_ID"), clientSecret: pm.vault.get("ADMIN_CLIENT_SECRET"), username: "admin@company.com", context: "full_access" }, "readonly": { clientId: pm.vault.get("READONLY_CLIENT_ID"), clientSecret: pm.vault.get("READONLY_CLIENT_SECRET"), username: "readonly@company.com", context: "read_only" } }; const currentUser = pm.environment.get("TEST_USER_PROFILE") || "admin"; const profile = userProfiles[currentUser]; if (profile) { pm.environment.set("TALLYFY_CLIENT_ID", profile.clientId); pm.environment.set("TALLYFY_CLIENT_SECRET", profile.clientSecret); pm.environment.set("TALLYFY_USERNAME", profile.username); console.log(`Switched to ${currentUser} profile (${profile.context})`); } else { console.error(`Unknown user profile: ${currentUser}`); } ``` ### 400 Bad Request on /oauth/token Token endpoint is picky about format: **Wrong content type**: ``` // You have: Content-Type: application/json // You need: Content-Type: application/x-www-form-urlencoded ``` **Wrong body format**: ```javascript // Wrong - JSON body: { "grant_type": "password", "username": "user@example.com" } // Right - URL encoded: grant_type=password&username=user@example.com&password=... ``` **Debug helper script**: ```javascript // Add to Pre-request Script to log what you're sending console.log("Token Request Details:"); console.log("URL:", pm.request.url.toString()); console.log("Method:", pm.request.method); console.log("Headers:", pm.request.headers.toObject()); console.log("Body mode:", pm.request.body.mode); if (pm.request.body.urlencoded) { console.log("Body params:"); pm.request.body.urlencoded.toObject().forEach(param => { console.log(` ${param.key}: ${param.value}`); }); } ``` ### Invalid client errors **"Invalid client" or "Client authentication failed"**: 1. **Wrong environment selected** - Check: `pm.environment.name` - Verify you're not using dev credentials against production 2. **Credentials don't match** - Client ID and Secret must be from same app - Organization ID must match the credentials 3. **Special characters in secrets** - If secret contains `+`, `/`, `=` ensure proper encoding - Use environment variables, not hard-coded values ## Data and request errors ### 404 Not Found **Wrong organization ID**: ```javascript // Debug: Log what you're using console.log("Org ID:", pm.environment.get("TALLYFY_ORG_ID")); console.log("Full URL:", pm.request.url.toString()); // Common issue: Using user ID instead of org ID // Wrong: user_123abc // Right: org_456def ``` **Resource was deleted**: ```javascript // Add error handling pm.test("Resource exists", function() { if (pm.response.code === 404) { console.error("Resource not found. It may have been deleted."); console.error("URL attempted:", pm.request.url.toString()); } }); ``` **API path typo**: ```javascript // Common typos: // Wrong: /organization/ (singular) // Right: /organizations/ (plural) // Wrong: /checklist/ (singular) // Right: /checklists/ (plural) // Wrong: /run/ (singular) // Right: /runs/ (plural) ``` ### 422 Unprocessable Entity This means your data format is wrong: **Missing required fields**: ```javascript // Log what you're sending console.log("Request body:", pm.request.body.raw); // Common missing fields: // - name (for process launch) // - captures (for task completion) // - field_id (for file uploads) ``` **Wrong data types**: ```javascript // Common type mismatches: // Number field expecting number, not string // Wrong: { "field_amount": "100.50" } // Right: { "field_amount": 100.50 } // Date field expecting specific format // Wrong: { "field_date": "Jan 1" } // Right: { "field_date": "YYYY-MM-DD" } // Boolean field // Wrong: { "field_approved": "true" } // Right: { "field_approved": true } ``` **Invalid enum values**: ```javascript // For select/radio fields, value must match exactly // Get valid options first: const template = pm.response.json(); const field = template.prerun_fields.find(f => f.id === "field_abc123"); console.log("Valid options:", field.options); ``` ## Rate limiting ### 429 Too Many Requests Tallyfy's limits: - 1000 requests per hour per organization - Resets on the hour (not rolling window) **Check your current usage**: ```javascript // Response headers tell you: const remaining = pm.response.headers.get("X-RateLimit-Remaining"); const reset = pm.response.headers.get("X-RateLimit-Reset"); console.log(`Requests remaining: ${remaining}`); console.log(`Resets at: ${new Date(reset * 1000).toLocaleTimeString()}`); ``` **Implement backoff strategy**: ```javascript // Exponential backoff for retries async function retryWithBackoff(requestFunction, maxRetries = 3) { let lastError; for (let i = 0; i < maxRetries; i++) { try { const response = await requestFunction(); if (response.code !== 429) { return response; } lastError = response; } catch (error) { lastError = error; } // Wait exponentially longer each retry const waitTime = Math.pow(2, i) * 1000; // 1s, 2s, 4s console.log(`Rate limited. Waiting ${waitTime}ms before retry ${i + 1}`); await new Promise(resolve => setTimeout(resolve, waitTime)); } throw lastError; } ``` **Batch operations efficiently**: ```javascript // Bad: Rapid fire requests tasks.forEach(task => { pm.sendRequest({...}); // All at once = rate limit }); // Good: Controlled spacing async function processTasksWithDelay(tasks, delayMs = 100) { for (const task of tasks) { await pm.sendRequest({...}); await new Promise(resolve => setTimeout(resolve, delayMs)); } } ``` ## File upload issues ### Files not uploading **Wrong body type**: ``` // Must use form-data, not raw JSON Body: form-data - file: [File type, select your file] - field_id: [Text type, "field_abc123"] ``` **File too large**: ```javascript // Check file size before upload // Tallyfy typically limits to 25MB const maxSize = 25 * 1024 * 1024; // 25MB in bytes ``` **Missing field_id**: ```javascript // File uploads need to know which field // Find field ID from task data: const task = pm.response.json(); const fileField = task.fields.find(f => f.type === 'file'); console.log("Use field_id:", fileField.id); ``` ## Debugging helpers ### Universal debug script Add this enterprise-grade debugging script to your collection's Pre-request Script: ```javascript // Enterprise-grade debugging for all requests // Inspired by Postman community best practices const debugLevel = pm.environment.get("DEBUG_LEVEL") || "INFO"; // DEBUG, INFO, WARN, ERROR const debugLevels = { DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3 }; const currentLevel = debugLevels[debugLevel] || 1; function debugLog(level, message, data = null) { if (debugLevels[level] >= currentLevel) { const timestamp = new Date().toISOString(); const prefix = `[${timestamp}] [${level}]`; if (data) { console.log(prefix, message, JSON.stringify(data, null, 2)); } else { console.log(prefix, message); } } } debugLog("INFO", "=== REQUEST DEBUG INFO ==="); debugLog("DEBUG", "Environment:", pm.environment.name); debugLog("INFO", "Request:", `${pm.request.method} ${pm.request.url.toString()}`); // Enhanced header validation const headers = pm.request.headers.toObject(); const requiredHeaders = ['Authorization', 'X-Tallyfy-Client']; const optionalHeaders = ['Content-Type', 'Accept', 'User-Agent']; debugLog("DEBUG", "Header Analysis:"); requiredHeaders.forEach(key => { const value = headers[key]; if (value) { const safeValue = key === 'Authorization' ? value.substring(0, 20) + '...' : value; debugLog("DEBUG", ` ✓ ${key}: ${safeValue}`); } else { debugLog("ERROR", ` ✗ ${key}: MISSING! This will cause 401 errors`); } }); optionalHeaders.forEach(key => { const value = headers[key]; if (value) { debugLog("DEBUG", ` ○ ${key}: ${value}`); } }); // Body validation with size checking if (pm.request.body && pm.request.body.mode) { debugLog("DEBUG", "Body mode:", pm.request.body.mode); if (pm.request.body.raw) { const bodySize = new Blob([pm.request.body.raw]).size; debugLog("DEBUG", `Body size: ${bodySize} bytes`); if (bodySize > 1024 * 1024) { // 1MB debugLog("WARN", "Large request body detected, may cause timeouts"); } try { const parsed = JSON.parse(pm.request.body.raw); debugLog("DEBUG", "Body (parsed):", parsed); // Validate JSON structure if (pm.request.method === "POST" && pm.request.url.toString().includes("/launch")) { if (!parsed.name) { debugLog("WARN", "Missing 'name' field in launch request"); } } } catch (e) { debugLog("WARN", "Body is not valid JSON:", pm.request.body.raw.substring(0, 200)); } } if (pm.request.body.formdata) { debugLog("DEBUG", "Form data fields:", pm.request.body.formdata.count()); pm.request.body.formdata.all().forEach(field => { if (field.type === 'file') { debugLog("DEBUG", ` File field: ${field.key}`); } else { debugLog("DEBUG", ` Text field: ${field.key} = ${field.value}`); } }); } } // Environment variable validation const criticalVars = { 'TALLYFY_ORG_ID': 'Organization ID for API context', 'TALLYFY_ACCESS_TOKEN': 'Bearer token for authentication', 'TALLYFY_BASE_URL': 'API base URL' }; debugLog("DEBUG", "Environment Variables:"); Object.entries(criticalVars).forEach(([key, description]) => { const value = pm.environment.get(key); if (value) { const safeValue = key.includes('TOKEN') ? value.substring(0, 20) + '...' : value; debugLog("DEBUG", ` ✓ ${key}: ${safeValue}`); } else { debugLog("ERROR", ` ✗ ${key}: NOT SET! (${description})`); } }); // Rate limiting awareness const lastRequestTime = pm.globals.get("LAST_REQUEST_TIME") || 0; const timeSinceLastRequest = Date.now() - lastRequestTime; if (timeSinceLastRequest < 100) { debugLog("WARN", `Fast consecutive requests (${timeSinceLastRequest}ms apart) - may hit rate limits`); } pm.globals.set("LAST_REQUEST_TIME", Date.now()); // Request sequence tracking const requestCount = pm.globals.get("REQUEST_COUNT") || 0; pm.globals.set("REQUEST_COUNT", requestCount + 1); debugLog("INFO", `Request #${requestCount + 1} in current session`); ``` ### Response analysis script Add this detailed response analyzer to your Tests tab: ```javascript // Detailed response analysis with performance tracking const debugLevel = pm.environment.get("DEBUG_LEVEL") || "INFO"; const responseTime = pm.response.responseTime; const statusCode = pm.response.code; // Performance analysis const performanceThresholds = { excellent: 500, good: 1000, acceptable: 2000, poor: 5000 }; let performanceRating = "poor"; if (responseTime <= performanceThresholds.excellent) performanceRating = "excellent"; else if (responseTime <= performanceThresholds.good) performanceRating = "good"; else if (responseTime <= performanceThresholds.acceptable) performanceRating = "acceptable"; console.log(`\n=== RESPONSE ANALYSIS (${performanceRating.toUpperCase()}: ${responseTime}ms) ===`); // Status code analysis with context const statusCategories = { 200: "Success", 201: "Created", 400: "Bad Request - Check your request format", 401: "Unauthorized - Authentication failed", 403: "Forbidden - Insufficient permissions", 404: "Not Found - Resource doesn't exist", 422: "Unprocessable Entity - Validation failed", 429: "Too Many Requests - Rate limit exceeded", 500: "Internal Server Error - API issue", 502: "Bad Gateway - API unavailable", 503: "Service Unavailable - Temporary outage" }; const statusContext = statusCategories[statusCode] || "Unknown status"; console.log(`Status: ${statusCode} (${statusContext})`); // Headers analysis const headers = pm.response.headers.toObject(); const importantHeaders = [ 'content-type', 'x-ratelimit-remaining', 'x-ratelimit-reset', 'cache-control', 'etag', 'last-modified' ]; console.log("Important Headers:"); importantHeaders.forEach(header => { const value = headers[header]; if (value) { console.log(` ${header}: ${value}`); } }); // Rate limiting analysis if (headers['x-ratelimit-remaining']) { const remaining = parseInt(headers['x-ratelimit-remaining']); if (remaining < 100) { console.warn(`⚠️ Rate limit warning: Only ${remaining} requests remaining`); } // Store for trend analysis const rateLimitHistory = JSON.parse(pm.environment.get("RATE_LIMIT_HISTORY") || '[]'); rateLimitHistory.push({ timestamp: Date.now(), remaining: remaining, endpoint: pm.request.url.getPath() }); // Keep only last 10 entries if (rateLimitHistory.length > 10) { rateLimitHistory.shift(); } pm.environment.set("RATE_LIMIT_HISTORY", JSON.stringify(rateLimitHistory)); } // Detailed error analysis if (statusCode >= 400) { console.error("\n=== ERROR DETAILS ==="); try { const body = pm.response.json(); console.error("Response body:", JSON.stringify(body, null, 2)); // Tallyfy-specific error formats if (body.error) { console.error(`\n🚨 Error: ${body.error}`); } if (body.message) { console.error(`💬 Message: ${body.message}`); } if (body.errors) { console.error("\n📋 Validation errors:"); Object.entries(body.errors).forEach(([field, errors]) => { const errorList = Array.isArray(errors) ? errors.join(', ') : errors; console.error(` • ${field}: ${errorList}`); }); } // Common error pattern detection const errorPatterns = { 'Invalid client': 'Check your CLIENT_ID and CLIENT_SECRET', 'Token expired': 'Refresh your access token', 'Missing start boundary': 'Remove manually set Content-Type header for file uploads', 'Validation failed': 'Check required fields and data types', 'Resource not found': 'Verify the resource ID and your permissions' }; const errorText = JSON.stringify(body).toLowerCase(); Object.entries(errorPatterns).forEach(([pattern, solution]) => { if (errorText.includes(pattern.toLowerCase())) { console.error(`\n💡 Suggested fix: ${solution}`); } }); } catch (e) { console.error("Body (text):", pm.response.text()); console.error("Note: Response body is not valid JSON"); } // Request context for debugging console.error("\n=== REQUEST CONTEXT ==="); console.error(`Method: ${pm.request.method}`); console.error(`URL: ${pm.request.url.toString()}`); console.error(`Environment: ${pm.environment.name}`); // Add to error log const errorLog = JSON.parse(pm.environment.get("ERROR_LOG") || '[]'); errorLog.push({ timestamp: new Date().toISOString(), status: statusCode, url: pm.request.url.toString(), method: pm.request.method, responseTime: responseTime, environment: pm.environment.name }); // Keep only last 20 errors if (errorLog.length > 20) { errorLog.shift(); } pm.environment.set("ERROR_LOG", JSON.stringify(errorLog)); } // Success analysis if (statusCode >= 200 && statusCode < 300) { try { const body = pm.response.json(); // Data quality checks if (Array.isArray(body.data)) { console.log(`✅ Retrieved ${body.data.length} items`); if (body.data.length === 0) { console.warn("⚠️ Empty result set - check your filters"); } } // Response structure validation const expectedFields = pm.environment.get("EXPECTED_RESPONSE_FIELDS"); if (expectedFields) { const fields = expectedFields.split(','); const missingFields = fields.filter(field => !body.hasOwnProperty(field)); if (missingFields.length > 0) { console.warn(`⚠️ Missing expected fields: ${missingFields.join(', ')}`); } } } catch (e) { console.log("✅ Request successful (non-JSON response)"); } } // Store response metrics const responseMetrics = JSON.parse(pm.environment.get("RESPONSE_METRICS") || '[]'); responseMetrics.push({ timestamp: Date.now(), endpoint: pm.request.url.getPath(), method: pm.request.method, status: statusCode, responseTime: responseTime, size: pm.response.text().length }); // Keep only last 50 metrics if (responseMetrics.length > 50) { responseMetrics.shift(); } pm.environment.set("RESPONSE_METRICS", JSON.stringify(responseMetrics)); ``` ## Getting help ### Before contacting support Postman experts recommend this systematic approach: 1. **Enable full logging**: ```javascript // Add to collection pre-request script pm.globals.set("DEBUG_SESSION_ID", pm.variables.replaceIn('{{$randomUUID}}')); pm.globals.set("DEBUG_START_TIME", new Date().toISOString()); ``` 2. **Capture complete diagnostic data**: - Enable Postman Console: View → Show Postman Console - Run the failing request with debug scripts enabled - Export console log: Save as file - Export your collection and environment (sanitized) 3. **Include these essential details**: - Exact error message and response code - Request details (method, full endpoint URL) - Response headers and body - Your organization ID (for context) - Timestamp of attempt - Postman version and operating system - Debug session ID from step 1 4. **Generate a support package**: ```javascript // Run this in Tests tab to generate support data const supportPackage = { sessionId: pm.globals.get("DEBUG_SESSION_ID"), timestamp: new Date().toISOString(), postmanVersion: pm.info.version, environment: pm.environment.name, request: { method: pm.request.method, url: pm.request.url.toString(), headers: pm.request.headers.toObject() }, response: { status: pm.response.code, headers: pm.response.headers.toObject(), time: pm.response.responseTime }, errorLog: JSON.parse(pm.environment.get("ERROR_LOG") || '[]'), performanceMetrics: JSON.parse(pm.environment.get("RESPONSE_METRICS") || '[]').slice(-5) }; console.log("\n=== SUPPORT PACKAGE ==="); console.log(JSON.stringify(supportPackage, null, 2)); console.log("\nCopy the above JSON and include it with your support request"); ``` ### Community resources **Postman Community**: Many Tallyfy API issues are common patterns. Search the Postman Community forums for: - "401 Unauthorized" solutions - "multipart/form-data" file upload issues - OAuth authentication troubleshooting - Environment variable management **Expert tip**: Before posting, search for your exact error message in quotes. ### Useful resources - [API Reference](https://go.tallyfy.com/api/)[1] - [Postman Community](https://community.postman.com/)[2] - [Status Page](https://status.tallyfy.com/)[3] - [Support Contact](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/) ### Self-diagnostic checklist Run through this expert checklist before seeking help: ```markdown ## Postman Diagnostic Checklist ### Authentication - [ ] X-Tallyfy-Client header present and set to "APIClient" - [ ] Authorization header format: "Bearer [token]" (exactly one space) - [ ] Token not expired (check TALLYFY_TOKEN_EXPIRY) - [ ] Using password grant, not client_credentials - [ ] Organization ID correct for your environment ### Request Format - [ ] Method appropriate for operation (POST for create, GET for read, etc.) - [ ] URL path correct and properly encoded - [ ] Content-Type header appropriate for body type - [ ] JSON body valid if using raw mode - [ ] Form-data configured correctly for file uploads (no manual Content-Type) ### Environment - [ ] Correct environment selected - [ ] All required variables set - [ ] No conflicting variables in different scopes - [ ] Network connectivity to go.tallyfy.com ### Response Analysis - [ ] Check response headers for rate limit info - [ ] Verify response body for specific error messages - [ ] Response time within acceptable range (<5 seconds) - [ ] No CORS issues (if testing from browser) ``` ## Advanced debugging techniques ### Network-level debugging Sometimes issues are at the network level. Use these Postman features: ```javascript // Network diagnostics in pre-request script const networkCheck = { startTime: Date.now(), dnsStart: Date.now() }; pm.globals.set("NETWORK_START", JSON.stringify(networkCheck)); // In test script - analyze timing const networkStart = JSON.parse(pm.globals.get("NETWORK_START")); const totalTime = Date.now() - networkStart.startTime; const responseTime = pm.response.responseTime; const networkTime = totalTime - responseTime; console.log(`Network timing: ${networkTime}ms network + ${responseTime}ms server = ${totalTime}ms total`); if (networkTime > 1000) { console.warn("High network latency detected - check connection"); } ``` ### Memory and performance debugging ```javascript // Memory usage tracking const memoryUsage = { environmentVars: Object.keys(pm.environment.toObject()).length, globalVars: Object.keys(pm.globals.toObject()).length, collectionVars: Object.keys(pm.collectionVariables.toObject()).length }; console.log("Memory usage:", memoryUsage); // Warn about memory leaks if (memoryUsage.environmentVars > 100) { console.warn("High environment variable count - consider cleanup"); } // Performance regression detection const currentResponseTime = pm.response.responseTime; const baselineTime = pm.environment.get("BASELINE_RESPONSE_TIME"); if (baselineTime && currentResponseTime > baselineTime * 1.5) { console.warn(`Performance regression: ${currentResponseTime}ms vs baseline ${baselineTime}ms`); } // Update rolling average const responseHistory = JSON.parse(pm.environment.get("RESPONSE_TIME_HISTORY") || '[]'); responseHistory.push(currentResponseTime); if (responseHistory.length > 10) { responseHistory.shift(); } const averageTime = responseHistory.reduce((a, b) => a + b, 0) / responseHistory.length; pm.environment.set("RESPONSE_TIME_HISTORY", JSON.stringify(responseHistory)); pm.environment.set("AVERAGE_RESPONSE_TIME", averageTime); ``` ### Automated issue detection ```javascript // Intelligent issue detection const issueDetector = { checkAuthentication() { const authHeader = pm.request.headers.get('Authorization'); const clientHeader = pm.request.headers.get('X-Tallyfy-Client'); const issues = []; if (!authHeader) { issues.push("Missing Authorization header"); } else if (!authHeader.startsWith('Bearer ')) { issues.push("Invalid Authorization header format"); } if (!clientHeader) { issues.push("Missing X-Tallyfy-Client header"); } else if (clientHeader !== 'APIClient') { issues.push("Invalid X-Tallyfy-Client header value"); } return issues; }, checkRequestBody() { const issues = []; if (pm.request.method === 'POST' && !pm.request.body) { issues.push("POST request without body"); } if (pm.request.body && pm.request.body.mode === 'raw') { try { JSON.parse(pm.request.body.raw); } catch (e) { issues.push("Invalid JSON in request body"); } } return issues; }, checkEnvironment() { const issues = []; const requiredVars = ['TALLYFY_BASE_URL', 'TALLYFY_ORG_ID', 'TALLYFY_ACCESS_TOKEN']; requiredVars.forEach(varName => { if (!pm.environment.get(varName)) { issues.push(`Missing environment variable: ${varName}`); } }); return issues; } }; // Run all checks const allIssues = [ ...issueDetector.checkAuthentication(), ...issueDetector.checkRequestBody(), ...issueDetector.checkEnvironment() ]; if (allIssues.length > 0) { console.error("🚨 Issues detected before sending request:"); allIssues.forEach(issue => console.error(` • ${issue}`)); } else { console.log("✅ Pre-flight checks passed"); } ``` ## Debugging best practices summary **The key insight for Postman debugging**: - Most issues: Missing X-Tallyfy-Client header or expired tokens - Fewer issues: Everything else (data format, permissions, network) **Expert workflow**: 1. Check X-Tallyfy-Client header first (always) 2. Verify token hasn't expired 3. Use Postman Console for detailed request/response inspection 4. Implement thorough logging scripts 5. Use environment variables for sensitive debugging data 6. Document common issues and solutions in collection descriptions Remember: The X-Tallyfy-Client header solves most problems. Check it first, always. ### Code samples - **[Authentication methods](https://tallyfy.com/products/pro/integrations/open-api/code-samples/authentication/)**: The Tallyfy API requires proper authentication through personal access tokens or OAuth flow along with specific headers to enable secure platform access and custom integrations. Authentication is required for almost all Tallyfy API endpoints. Choose an authentication method below based on your use case: Remember to include the necessary headers (`Authorization`, `Accept`, `X-Tallyfy-Client`) in all your requests as shown in the examples. - **[Managing groups](https://tallyfy.com/products/pro/integrations/open-api/code-samples/groups/)**: API endpoints enable management of organizational groups through creating listing updating and deleting functionalities while organizing members and guests for various tasks. Groups in Tallyfy help you organize members and guests for assignment to tasks and processes. Use the API to create, list, retrieve details, update, and remove groups. Refer to the individual pages for specific request details and code examples. - **[Managing files](https://tallyfy.com/products/pro/integrations/open-api/code-samples/files/)**: The API enables file management functionalities including uploading downloading getting metadata and removing files associated with tasks or kick-off forms. Tallyfy's API allows you to upload files and associate them with tasks or kick-off forms. Refer to the individual pages for specific request details and code examples. - **[Managing processes (Runs)](https://tallyfy.com/products/pro/integrations/open-api/code-samples/processes/)**: The API facilitates process management by enabling users to launch retrieve update and control the lifecycle of running instances while providing integration capabilities for tasks templates and organizational tags. Processes (referred to as "Runs" in the Tallyfy API) are live instances launched from templates. You can use the Tallyfy API to launch new processes, retrieve their status and data, update them, and manage their complete lifecycle. Refer to the individual pages for specific request details and code examples. - **[Managing tags](https://tallyfy.com/products/pro/integrations/open-api/code-samples/tags/)**: The API enables comprehensive tag management by allowing users to create list retrieve update and archive tags for organizing templates processes tasks and steps. Tags help categorize and filter templates, processes, tasks, and steps. Use the API to create, list, retrieve details, update, and manage tags. Refer to the individual pages for specific request details and code examples. - **[Managing guests](https://tallyfy.com/products/pro/integrations/open-api/code-samples/guests/)**: External users can access and complete specific assigned tasks through unique links without requiring full system accounts while organizations maintain control over process visibility and data security. Guests are external users who can be invited to participate in specific Tallyfy tasks or processes without needing a full member account. Use the Tallyfy API to create, list, retrieve details, update, and remove guests. Refer to the individual pages for specific request details and code examples. - **[Managing tasks](https://tallyfy.com/products/pro/integrations/open-api/code-samples/tasks/)**: The API enables comprehensive task management through listing retrieving creating updating and controlling individual work units within process runs or as standalone operations. Tasks represent individual units of work within a Tallyfy process run or as standalone one-off tasks. Use the Tallyfy API to list, retrieve, create, update, and manage tasks. Refer to the individual pages for specific request details and code examples. - **[Managing members (Users)](https://tallyfy.com/products/pro/integrations/open-api/code-samples/members/)**: The API enables organizations to manage their registered users through functionalities like inviting listing updating and removing members along with their roles and profiles. Members (referred to as "Users" in the API) are registered users within your Tallyfy organization. You can use the Tallyfy API to invite, list, retrieve details, update, and manage members. Refer to the individual pages for specific request details and code examples. - **[Managing templates (blueprints)](https://tallyfy.com/products/pro/integrations/open-api/code-samples/templates/)**: API endpoints enable managing process templates through actions like creating retrieving updating publishing exporting and deleting template definitions in an organization. ## Templates in the API Tallyfy process templates (referred to as "Checklists" or "Blueprints" in the API) define the structure of your repeatable processes. While in the Tallyfy user interface these are called **Templates**, the API endpoints consistently use the term **Blueprints** to refer to the same objects. :::note[Important Terminology Difference] **UI Terminology**: Templates **API Terminology**: Blueprints (or sometimes Checklists) This distinction is important to remember when developing with the API versus using the Tallyfy interface. ::: Use the Tallyfy API to create, retrieve, update, and manage these templates/blueprints. Refer to the individual pages for specific request details and code examples. ### Authentication - **[Use the Client Credentials Flow](https://tallyfy.com/products/pro/integrations/open-api/code-samples/authentication/client-credentials-flow/)**: The OAuth 2.0 Client Credentials flow enables machine-to-machine authentication for third-party applications requiring manual setup by Tallyfy Support with client credentials that generate application-level tokens valid for 7 days and optional user-specific tokens valid for 3 months for acting as individual users. ## Overview The OAuth 2.0 Client Credentials flow is designed for machine-to-machine authentication, typically used by third-party applications or backend services that need to interact with the Tallyfy API independently or on behalf of users within an organization. This method requires you to first obtain a `Client ID` and `Client Secret` from Tallyfy Support. :::caution[Enterprise Feature & Setup Required] The client credentials grant type is only available to paid Tallyfy organizations and requires manual setup by Tallyfy Support. It is not accessible during free trials or by default. Contact Tallyfy Support to request access and explain your integration use case. ::: ## Authentication flow This diagram shows the complete OAuth 2.0 Client Credentials flow from initial setup through API usage. [Diagram removed for brevity] ### What to notice - **Step 1 is manual**: Contacting Tallyfy Support for credentials is a one-time setup process that cannot be automated - **Two token types**: Application tokens (for system operations) vs user-specific tokens (for acting as a user) - **Different expiration times**: Application tokens expire in 7 days (604,800 seconds), user-specific tokens expire in 3 months (7,776,000 seconds) ### Use cases This integration pattern is ideal for organizations using Tallyfy that want to: - Embed Tallyfy functionality within their own software. - Provide integrated workflow capabilities to their users without requiring separate Tallyfy logins visible in your app. - Automate process management or user provisioning programmatically. - System-level integrations (e.g., reporting, data synchronization). - Handle Tallyfy user provisioning programmatically ### Steps #### 1. Request client credentials - Contact Tallyfy Support to request client credentials (`Client ID` and `Client Secret`). - Explain your integration needs and use case. - Tallyfy will provide the credentials for your organization. Store these credentials securely. #### 2. Obtain an application access token Your application first needs its *own* access token to perform actions like Tallyfy user provisioning or getting user-specific tokens. - **Endpoint:** `POST /oauth/token` - **OAuth Endpoint:** `https://account.tallyfy.com/oauth/token` - **Content-Type:** `application/x-www-form-urlencoded` - **Request Body (form-encoded):** - `grant_type`: `client_credentials` - `client_id`: Your Application\'s Client ID - `client_secret`: Your Application\'s Client Secret - `scope`: `*` (or specific scopes if provided by Tallyfy) **Response:** ```json { "token_type": "Bearer", "expires_in": 604800, "access_token": "APP_LEVEL_ACCESS_TOKEN_EXAMPLE..." } ``` :::note[Token Expiration] Application access tokens are valid for 7 days (604,800 seconds). Your application should request a new token before expiration - simply repeat the POST request with your credentials. ::: :::note[Endpoint URLs] - **OAuth Token Endpoint:** `https://account.tallyfy.com/oauth/token` - for obtaining application tokens - **API Base URL:** `https://go.tallyfy.com/api` - for all other API calls after authentication ::: ### 3. Provision users programmatically (Optional) Using the application-level token, you can create users in your organization: - **Endpoint:** `POST https://go.tallyfy.com/api/applications/{orgID}/users` - **Headers:** - `Authorization: Bearer {your_app_access_token}` (From Step 2) - `Content-Type: application/json` - `X-Tallyfy-Client: APIClient` - **Request Body:** - `first_name` (required): User's first name - `last_name` (required): User's last name - `email` (required): User's email address - `role` (optional): `admin`, `standard`, or `light` - `timezone` (optional): User's timezone ### 4. Generate user-specific access tokens (Optional) To act *as* a specific user, request a user-specific token using the application token. - **Endpoint:** `POST https://go.tallyfy.com/api/applications/{orgID}/users/{email}/token` - **Headers:** - `Authorization: Bearer {your_app_access_token}` (From Step 2) - `X-Tallyfy-Client: APIClient` - **Note:** No request body required - the user email is in the URL path. **Response:** ```json { "token_type": "Bearer", "expires_in": 7776000, "access_token": "USER_SPECIFIC_ACCESS_TOKEN_EXAMPLE..." } ``` :::note[User Token Validity] User-specific tokens are valid for 3 months (7,776,000 seconds). ::: ### 5. Make API requests as an application or user Use the appropriate token (`APP_LEVEL_ACCESS_TOKEN` or `USER_SPECIFIC_ACCESS_TOKEN`) in the `Authorization: Bearer {token}` header for subsequent API calls, along with the standard `Accept` and `X-Tallyfy-Client` headers. **Example: Get tasks for a specific user (using user-specific token)** - **Endpoint:** `GET /organizations/{orgID}/me/tasks` - **Base URL:** `https://go.tallyfy.com/api` - **Resource Path:** e.g., `/organizations/{org_id}/users` - **Full URL:** `https://go.tallyfy.com/api/organizations/{org_id}/users` - **Headers:** - `Authorization: Bearer {user_specific_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` *Code examples for making the requests themselves are similar to those shown in the [Personal Access Token](/products/pro/integrations/open-api/code-samples/authentication/personal-access-token/) guide, just substitute the correct token.* ### Security considerations - Store client credentials securely (e.g., encrypted secrets management). - Protect both application-level and user-specific tokens. - Rotate secrets periodically. - Use HTTPS for all communications. - Implement robust token expiration and refresh logic. --- - **[Get & use a personal access token](https://tallyfy.com/products/pro/integrations/open-api/code-samples/authentication/personal-access-token/)**: The Tallyfy API uses personal access tokens for authentication which requires including the token in the Authorization header along with Accept and X-Tallyfy-Client headers for all API requests with tokens being invalidated upon logout. ## Overview The primary way to authenticate with the Tallyfy API is using your personal `access_token`. This token acts on your behalf, granting API requests the same permissions you have within Tallyfy. Simple and straightforward - no OAuth dance required for basic usage. ### Getting your personal access token 1. Log in to your Tallyfy account at [https://go.tallyfy.com/](https://go.tallyfy.com/). 2. Navigate to **Settings** (usually via your profile picture or menu). 3. Go to the **Integrations** section. 4. Select **REST API**. 5. Your personal `access_token` will be displayed here. Copy it securely. :::caution[Keep Your Token Secure] Treat your personal access token like a password. Do not share it publicly or commit it to version control. Anyone with your token can access your Tallyfy data. Yes, this includes that "temporary" commit you were planning to fix later. ::: :::warning[Token Invalidation on Logout] **Important**: Your personal access token is automatically invalidated and regenerated every time you log out of Tallyfy. This is a security feature that can impact your integrations. **What causes token invalidation**: - Manual logout from the web interface - Automatic session timeout after inactivity - Browser clearing cookies/sessions - Switching between multiple Tallyfy organizations - Password reset operations **Impact on automations**: - All API calls using the old token will return 401/403 errors - Automations will stop working immediately - You'll need to manually update the token in all integrations **Best practices for stable API access**: 1. **Dedicated service accounts** - Create a specific user for API integrations who never logs out 2. **Error handling** - Implement 401/403 detection with alerts for token refresh 3. **Token monitoring** - Track token validity and alert on unexpected changes 4. **Document dependencies** - Keep a list of all systems using each token 5. **Consider OAuth flow** - For production systems, use OAuth with refresh tokens 6. **Enterprise options** - Contact support about application tokens that don't expire on logout ::: :::note[API Access Plans] Direct API access using personal tokens is typically available on paid Tallyfy plans. If you are on a trial or free plan, contact Tallyfy Support to request API access (they're pretty responsive). ::: ### Using your token in API requests Once you have your token, you need to include it in the `Authorization` header of every API request you make. The format is `Bearer {your_access_token}`. You also need to include two other standard headers: - `Accept: application/json` (Tells the API you expect a JSON response) - `X-Tallyfy-Client: APIClient` (Identifies the request as coming from a custom API client - don't forget this header or you'll get 401s) Here's how to add these headers in different languages: Remember to replace `YOUR_PERSONAL_ACCESS_TOKEN` and `YOUR_ORGANIZATION_ID` with your actual Tallyfy values. (And please don't copy-paste these placeholders into production - we've all been there, but it's never fun to debug.) --- ### Groups - **[Create group](https://tallyfy.com/products/pro/integrations/open-api/code-samples/groups/create-group/)**: This documentation explains how to create a new group within a Tallyfy organization using a POST API endpoint that accepts group details like name and description along with optional member IDs and guest email addresses through authenticated requests in various programming languages. ## Endpoint `POST /organizations/{org_id}/groups` This endpoint creates a new group within your Tallyfy organization. ## Request Replace `{org_id}` with your Organization ID. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` - `Content-Type: application/json` ### Body (JSON) The request body requires a JSON object defining the new group. Refer to the `#definitions/createGroupInput` schema in Swagger. Key fields: - `name` (string, required): The name of the group. - `description` (string, optional): A description for the group. - `members` (array of integers, optional): An array of User IDs for members to add to the group. - `guests` (array of strings, optional): An array of email addresses for guests to add to the group. **Minimal Example Body:** ```json { "name": "Project Alpha Team" } ``` **Example Body with Members/Guests:** ```json { "name": "Onboarding Specialists", "description": "Team responsible for new client onboarding.", "members": [1001, 1005, 1008], "guests": ["client.liaison@partner.com"] } ``` ## Code Samples ## Response A successful request returns a `200 OK` or `201 Created` status code and a JSON object containing the details of the newly created group, including its assigned `id`. ```json { "data": { "id": "new_group_id_789", "name": "Onboarding Specialists", "description": "Team responsible for new client onboarding.", "logo": null, "members": [1001, 1005, 1008], "guests": ["client.liaison@partner.com"], "created_at": "YYYY-MM-DDTHH:MM:SSZ", "updated_at": "YYYY-MM-DDTHH:MM:SSZ", "deleted_at": null } } ``` Make note of the returned `id` to manage this group later through Tallyfy's API (get, update, delete). --- - **[Get group](https://tallyfy.com/products/pro/integrations/open-api/code-samples/groups/get-group/)**: The GET endpoint allows retrieving detailed information about a specific group within an organization using its unique ID through authenticated API requests with code examples in multiple programming languages. ## Endpoint `GET /organizations/{org_id}/groups/{group_id}` This endpoint retrieves the details for a single group in your Tallyfy organization identified by its unique ID. ## Request Replace `{org_id}` with your Organization ID and `{group_id}` with the specific ID of the group you want to retrieve. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Query parameters (optional) - `with` (string): Include additional related data, e.g., `assets` (for group logo). - Pagination parameters might be available. ### Code samples ## Response A successful request returns a `200 OK` status code and a JSON object containing the group details in the `data` field. - **[Delete group](https://tallyfy.com/products/pro/integrations/open-api/code-samples/groups/delete-group/)**: A DELETE endpoint removes organizational groups while maintaining individual member and guest accounts by requiring authentication headers and returning status codes 200 or 204 upon successful deletion. ## Endpoint `DELETE /organizations/{org_id}/groups/{group_id}` This endpoint deletes an existing group from your Tallyfy organization. This typically does not delete the members or guests themselves, only the group association. ## Request Replace `{org_id}` with your Organization ID and `{group_id}` with the ID of the group to delete. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Body No request body is needed for this DELETE request. ### Code samples ## Response A successful request returns either a `200 OK` status code with a JSON object containing the deleted group details, or a `204 No Content` status code indicating successful deletion. - **[List groups](https://tallyfy.com/products/pro/integrations/open-api/code-samples/groups/list-groups/)**: This documentation explains how to retrieve a list of groups within a Tallyfy organization using a GET API endpoint with code examples provided in JavaScript Python Java Go C++ and C# that demonstrate the request structure including required authorization headers and optional query parameters for including additional data like group logos. ## Endpoint `GET /organizations/{org_id}/groups` This endpoint retrieves a list of groups defined within your Tallyfy organization. ## Request Replace `{org_id}` with your Organization ID. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Query parameters (optional) - `with` (string): Include additional data, e.g., `assets` (for group logo). - Pagination parameters might be available. ### Code samples ## Response A successful request returns a `200 OK` status code and a JSON object containing a `data` array. Each element represents a group in your Tallyfy organization. ```json { "data": [ { "id": "group_id_abc123", // Unique group ID "name": "Sales Team", "description": "Handles all sales inquiries.", "logo": null, // Or URL if logo uploaded and requested with 'with=assets' "members": [1001, 1005], // Array of member user IDs "guests": ["client.a@example.com"], // Array of guest emails "created_at": "2023-01-15T09:00:00Z", "updated_at": "2023-06-20T10:00:00Z", "deleted_at": null }, { "id": "group_id_def456", "name": "Support Tier 1", // ... other group details ... } ] // Potential meta object for pagination } ``` --- - **[Update group](https://tallyfy.com/products/pro/integrations/open-api/code-samples/groups/update-group/)**: This endpoint allows you to modify an existing group's properties like name and description as well as its membership by sending a PUT request with the updated fields in JSON format where providing member or guest arrays will completely replace the existing lists rather than incrementally updating them. ## Endpoint `PUT /organizations/{org_id}/groups/{group_id}` This endpoint updates the details (name, description) and/or the membership (members, guests) of an existing group in your Tallyfy organization. ## Request Replace `{org_id}` with your Organization ID and `{group_id}` with the ID of the group to update. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` - `Content-Type: application/json` ### Body (JSON) The request body requires a JSON object containing the group properties you wish to modify. You only need to include the fields you want to change. Refer to the `#definitions/createGroupInput` schema (often similar to update) in Swagger. Key fields: - `name` (string): New name for the group. - `description` (string): New description. - `members` (array of integers): **Replaces** the current list of member IDs in the group. - `guests` (array of strings): **Replaces** the current list of guest emails in the group. **Example Body (Updating name and members):** ```json { "name": "Project Alpha Core Team", "members": [1001, 1008, 1010] // User 1005 removed, 1008/1010 added } ``` :::caution[Membership Updates Replace] Providing the `members` or `guests` arrays *replaces* the entire existing list for that type within the group. To add or remove individuals incrementally, you typically need to first get the current group details, modify the list in your code, and then send the complete new list in the PUT request. ::: ### Code samples ## Response A successful request returns a `200 OK` status code and a JSON object containing the full details of the group *after* the update. ```json { "data": { "id": "GROUP_ID_TO_UPDATE", "name": "Project Alpha Core Team", // Updated name "description": "Updated team description.", // Updated description "members": [1001, 1008, 1010], // Updated members list "guests": [], // Updated guests list // ... other group properties ... "updated_at": "YYYY-MM-DDTHH:MM:SSZ" // Reflects update time } } ``` If the group ID is not found, you lack permission, or the request body is invalid, an appropriate error status code (`404`, `403`, `400`, `422`) will be returned. --- ### Files - **[Delete file](https://tallyfy.com/products/pro/integrations/open-api/code-samples/files/delete-file/)**: A DELETE endpoint that removes uploaded files from tasks or kick-off forms by making authorized requests to either /organizations/{org_id}/file/{asset_id} or /organizations/{org}/assets/{assetID} endpoints and returns a 200 OK status code upon successful deletion. ## Endpoint `DELETE /organizations/{org_id}/file/{asset_id}` This endpoint deletes an uploaded file (asset) in Tallyfy, removing it from the task or kick-off form field it was attached to. :::note[Alternative Endpoint] The Swagger specification also lists `DELETE /organizations/{org}/assets/{assetID}` which seems functionally identical. Use whichever works or is recommended by Tallyfy Support. ::: :::caution[Action Scope] This action deletes the specific asset record and its association with the form field. It does not necessarily delete the underlying file from storage immediately, but makes it inaccessible through Tallyfy. ::: ## Request Replace `{org_id}` with your Organization ID and `{asset_id}` with the Asset ID of the file to delete. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Body No request body is needed for this DELETE request. ### Code samples ## Response A successful request returns a `200 OK` status code, confirming the file has been deleted from Tallyfy. - **[Download file](https://tallyfy.com/products/pro/integrations/open-api/code-samples/files/download-file/)**: The Tallyfy API provides endpoints to download or view files inline using GET requests with organization and file IDs where the response returns raw file content with appropriate Content-Type headers rather than JSON data. ## Endpoints - `GET /organizations/{org_id}/file/{file_id}` — View the file inline (where supported). - `GET /organizations/{org_id}/file/{file_id}/dl` — Download the file as an attachment. Both endpoints return the actual file content for an asset previously uploaded to Tallyfy (e.g., via a task field or kick-off field). Use the `/dl` suffix when you explicitly want a download attachment response. ## Request Replace `{org_id}` with your Organization ID and `{file_id}` with the Asset ID of the file you want to download (this ID is obtained when uploading the file or potentially from getting task/process data). ### Headers - `Authorization: Bearer {your_access_token}` - `X-Tallyfy-Client: APIClient` - *(Accept header might be omitted or set based on expected file type, but the API primarily controls the response `Content-Type`)* ### Query parameters (optional) No common query parameters are typically needed for this endpoint. ### Code samples (download as attachment) These samples demonstrate how to fetch the file content and save it locally. Error handling should check the response status and `Content-Type` header. ### Viewing inline To display the file inline (when the client supports the MIME type), request the inline endpoint without `/dl`: ```bash curl -X GET \ -H "Authorization: Bearer $TALLYFY_ACCESS_TOKEN" \ -H "X-Tallyfy-Client: APIClient" \ "https://go.tallyfy.com/api/organizations/$TALLYFY_ORG_ID/file/$FILE_ID" ``` ## Response A successful request returns a `200 OK` status code. The response body **is the raw file content**, not JSON. - The `Content-Type` header indicates the MIME type of the file (e.g., `image/png`, `application/pdf`). - The `Content-Disposition` header often suggests a filename (e.g., `attachment; filename="report.pdf"`). Your code should parse this header to save the file with its original name if desired. If the file ID is invalid or access is denied, Tallyfy will return an appropriate error status code (`404`, `403`), likely with an error message in the body (which might be JSON or plain text). --- - **[Get file metadata](https://tallyfy.com/products/pro/integrations/open-api/code-samples/files/get-file-metadata/)**: This API endpoint retrieves metadata for a specific uploaded file asset in Tallyfy by making a GET request with organization and asset IDs and returns details like filename and upload date in a JSON response. ## Endpoint `GET /organizations/{org_id}/assets/{asset_id}` This endpoint retrieves metadata (like filename, upload date, related object) for a specific uploaded file (referred to as an "Asset" in Tallyfy's API). ## Request Replace `{org_id}` with your Organization ID and `{asset_id}` with the Asset ID of the file whose metadata you want. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Query parameters (optional) No common query parameters are typically needed for this endpoint. ### Code samples ## Response A successful request returns a `200 OK` status code and a JSON object containing a `data` array (usually with one element) holding the asset metadata. ```json { "data": [ { "id": "ASSET_ID_TO_GET_METADATA", "filename": "report_q1.pdf", "version": 1, "step_id": "step_id_xyz789", // If related to a task step "uploaded_from": "capture_id_abc123", // Form field ID or 'ko_field' "uploaded_to_s3": true, "subject": { "id": "run_id_or_checklist_id", "type": "Run" // Or "Checklist" }, "uploaded_at": "YYYY-MM-DDTHH:MM:SSZ" // Other potential metadata fields like size, uploader ID, etc. } ] } ``` If the asset ID is not found or you lack permission, Tallyfy will return a `404` or `403` error. --- - **[Upload & attach file](https://tallyfy.com/products/pro/integrations/open-api/code-samples/files/upload-attach-file/)**: Attaching files to form fields via Tallyfy's API requires uploading the file to get an asset reference and then updating the task or process to link that asset to the specific form field using the proper endpoint and field identifiers. Attaching files (like images or documents) to form fields via Tallyfy's API usually involves two main steps for files stored locally on your system: 1. **Upload the file:** Send the file content to Tallyfy's file endpoint to get an asset reference. 2. **Update the task/process:** Use the asset reference obtained in step 1 to update the corresponding task or process, linking the file to the specific form field. Alternatively, for files already hosted publicly online, you might be able to link them directly in a single step (see Method 2 in the older article content, though this might be less common and subject to change - prioritize the upload method). ### Method 1: Upload a local file (Recommended) ### Step 1: Upload the file #### Endpoint `POST /organizations/{org_id}/file` #### Request type `multipart/form-data` This request uploads the raw file data. It requires specific form data fields to correctly categorize the upload. #### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` - *(Content-Type header will be set automatically by your HTTP client for multipart/form-data)* #### Form data fields (required) | Field | Description | Example Value | |---|---|---| | `name` | The actual file binary data. | *(Select file in your client)* | | `uploaded_from` | Context of upload. For **Tasks**, use the **Form Field ID (Capture ID)**. For **Kick-off**, use `ko_field`. | `capture_id_abc123` or `ko_field` | | `subject_type` | Type of object the file relates to. | `Run` (for Tasks) or `Checklist` (for Kick-off) | | `subject_id` | ID of the object type. | `{run_id}` (for Tasks) or `{checklist_id}` (for Kick-off) | | `source` | How the file is provided. | `local` | | `step_id` | **Required only for Tasks.** The ID of the **Step** within the template that the task belongs to. | `step_id_xyz789` | | `checklist_id` | **Required only for Tasks.** The ID of the template (Checklist) that the process run was launched from. | `template_id_efg456` | :::tip[Finding IDs] - Form Field IDs (`uploaded_from` for tasks), Step IDs, Run IDs, Checklist IDs can often be found by using the `GET` endpoints for Tasks, Processes (Runs), or Templates with the `with` parameter (e.g., `with=step,form_fields`). ::: #### Code samples for Step 1: Upload (Note: Handling `multipart/form-data` varies significantly between languages and libraries. These are conceptual examples.) #### Response examples for Step 1: Upload A successful upload returns `200 OK` and a JSON response containing an array usually with one element: the asset object representing the uploaded file. You'll need this object for Step 2. ```json { "data": [ { "id": "asset_id_abc123xyz", // The Asset ID "filename": "document.pdf", "version": 1, "step_id": "step_id_xyz789", // If uploaded for a task "uploaded_from": "capture_id_abc123", // Form Field ID or ko_field "subject": { "id": "run_id_or_checklist_id", "type": "Run" // or "Checklist" }, "url": "/internal/url/not/usually/needed/directly", "uploaded_at": "2023-01-15T10:00:00Z" // Potentially other fields like uploaded_to_s3 } ] } ``` **Extract the entire object** within the `data` array (e.g., `response.data[0]` in JavaScript) for the next step. ### Step 2: Attach uploaded file to field Now, use the asset object obtained from Step 1 to update the specific task or process run, linking the file to the form field. #### Endpoint - **Process Task:** `PUT /organizations/{org_id}/runs/{run_id}/tasks/{task_id}` - **Kick-off Form:** `PUT /organizations/{org_id}/checklists/{checklist_id}` (Modify the `prerun` field in the template update payload) #### Request type `application/json` #### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` - `Content-Type: application/json` #### Body JSON for task fields Update the task using its endpoint. The body should include a `taskdata` object targeting the file field ID. The value should be an **array containing the asset object** from Step 1. ```json { "taskdata": { "CAPTURE_ID_OF_FILE_FIELD": [ { "id": "asset_id_abc123xyz", "filename": "document.pdf", "version": 1, "step_id": "step_id_xyz789", "uploaded_from": "capture_id_abc123", "subject": { "id": "run_id_or_checklist_id", "type": "Run" }, "url": "...", "uploaded_at": "...", "uploaded_to_s3": true } ] } // You can include other task updates here too (e.g., summary, deadline) } ``` #### Body JSON for kick-off fields Update the template using its endpoint. The body needs to include the `prerun` array, modifying the entry for your file field. The `value` for the file field should be an **array containing the asset object** from Step 1. ```json { "prerun": [ // ... other prerun fields (MUST include their existing IDs and values or they might be removed) ... { "id": "PRERUN_FIELD_ID_FOR_FILE", // ID of the kick-off field // It's safest to fetch the existing prerun fields first and modify only the target one. // Include other necessary properties for this field (like label, field_type, required etc.). "value": [ // The value is an array containing the asset object // Paste the entire asset object from Step 1 response's data[0] here { "id": "asset_id_abc123xyz", "filename": "document.pdf", // ... all other fields from Step 1 data[0] ... } ] } // ... other prerun fields ... ] // Include other template updates if needed (e.g., title) } ``` :::caution[Updating Arrays (Prerun/Taskdata)] When updating fields that expect arrays (like file fields or multi-selects), ensure you provide the *complete* array value you want to set. Sending just the new item might overwrite existing items. For `prerun`, when updating one kick-off field, you typically need to send the *entire* `prerun` array containing all other kick-off fields with their current values, otherwise they might be removed or reset. Fetch the template first to get the current structure. ::: #### Code samples for Step 2: Attach file to task (These examples assume you have the `assetObject` from the Step 1 response and the necessary IDs: `orgId`, `runId`, `taskId`, `formFieldId`) #### Response examples for Step 2: Attach A successful `PUT` request returns `200 OK` and the updated Task or Checklist object, reflecting the file attachment in the `taskdata` or `prerun.value` respectively. ```json { // ... other task properties ... "taskdata": { "CAPTURE_ID_OF_FILE_FIELD": [ { "id": "asset_id_abc123xyz", "filename": "document.pdf", "version": 1, "step_id": "step_id_xyz789", "uploaded_from": "capture_id_abc123", "subject": { "id": "run_id_or_checklist_id", "type": "Run" }, "url": "...", "uploaded_at": "...", "uploaded_to_s3": true } ] } // ... other task properties ... } ``` :::note[Common mistakes and troubleshooting] - **Do not use invalid routes**: `/assets/{id}/dl` does not exist. To download, use `GET /organizations/{org_id}/file/{file_id}/dl`. To view inline, use `GET /organizations/{org_id}/file/{file_id}`. - **Attach after upload**: Uploading creates an Asset, but it is not attached to a field until you update the Task using `PUT /organizations/{org_id}/runs/{run_id}/tasks/{task_id}` with the asset placed under the field’s Capture ID inside `taskdata` as an array. - **Send the entire asset object**: Place the full object from the upload response’s `data[0]` inside the array for the file field in `taskdata`. - **Verify upload context fields** (Task uploads): `uploaded_from` must be the field’s Capture ID; `subject_type` must be `Run`; `subject_id` must be the `run_id`; include both `checklist_id` and `step_id`. - **Verify upload context fields** (Kick-off uploads): `uploaded_from` must be `ko_field`; `subject_type` must be `Checklist`; `subject_id` must be the `checklist_id`. ::: --- ### Processes - **[Activate process](https://tallyfy.com/products/pro/integrations/open-api/code-samples/processes/activate-process/)**: This endpoint uses a PUT request to restore a previously archived Tallyfy process instance back to its active state by removing the archived timestamp and updating its status through authenticated API calls with organization and run identifiers. ## Endpoint `PUT /organizations/{org_id}/runs/{run_id}/activate` This endpoint restores (unarchives) a previously archived Tallyfy process instance (run), making it active again. ## Request Replace `{org_id}` with your Organization ID and `{run_id}` with the ID of the process run to activate. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Body No request body is needed for this PUT request. ### Code samples ## Response A successful request returns a `200 OK` status code. The response body contains the details of the reactivated Tallyfy process run, with the `archived_at` timestamp removed and the `status` updated to its pre-archive state. ```json { "data": { "id": "PROCESS_RUN_ID_TO_ACTIVATE", "name": "Restored Project Run", "status": "active", // Or 'complete', etc. "archived_at": null, // Timestamp is removed // ... other process properties ... "last_updated": "..." // Reflects activation time } } ``` If the process run ID is not found, was not archived, or you lack permission, an error status code (`404`, `400`, `403`) will be returned. --- - **[Archive process](https://tallyfy.com/products/pro/integrations/open-api/code-samples/processes/archive-process/)**: This DELETE endpoint archives a Tallyfy process instance by hiding it from default views while preserving all data for potential future restoration and returns the archived process details with an updated status and timestamp upon successful completion. ## Endpoint `DELETE /organizations/{org_id}/runs/{run_id}` This endpoint archives a specific Tallyfy process instance (run). Archiving hides the process from default views while retaining all data for future restoration. ## Request Replace `{org_id}` with your Organization ID and `{run_id}` with the ID of the process run to archive. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Body No request body is needed for this DELETE request. ### Code samples ## Response A successful request returns a `200 OK` status code. The response body contains the details of the archived Tallyfy process run, including an `archived_at` timestamp and a `status` of `archived`. ```json { "data": { "id": "PROCESS_RUN_ID_TO_ARCHIVE", "name": "Old Completed Project", "status": "archived", // Status reflects archive // ... other process properties ... "archived_at": "YYYY-MM-DDTHH:MM:SSZ" // Timestamp indicates archival } } ``` If the process run ID is not found or you lack permission, a `404` or `403` error will be returned. --- - **[Delete process](https://tallyfy.com/products/pro/integrations/open-api/code-samples/processes/delete-process/)**: The DELETE endpoint permanently removes a process run instance and its associated data including tasks comments and form values with no option for recovery. ## Endpoint `DELETE /organizations/{org_id}/runs/{run_id}/delete` This endpoint permanently deletes a specific Tallyfy process instance (run) and all its associated data (tasks, comments, form field values, etc.). :::danger[Irreversible Action] Permanently deleting a Tallyfy process run cannot be undone. All data related to this specific run will be lost. Consider archiving unless you're absolutely certain. ::: ## Request Replace `{org_id}` with your Organization ID and `{run_id}` with the ID of the process run to delete permanently. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Body No request body is needed for this DELETE request. ### Code samples ## Response A successful permanent deletion typically returns a `200 OK` or `204 No Content` status code. - If `200 OK`, the body might contain a success message. - If `204 No Content`, the deletion was successful, and there is no response body. If the process run ID is not found or you lack permission, an error (`404`, `403`) will be returned. --- - **[Get activity feed for a process](https://tallyfy.com/products/pro/integrations/open-api/code-samples/processes/get-process-activity/)**: The activity feed API provides a complete audit trail for retrieving all process actions including task completions comments status changes and assignments through GET requests to the activity-feeds endpoint with filtering options for entity type verb actor and pagination support across JavaScript Python Java and Go implementations. ## Retrieving process activity feed via API The activity feed API provides a complete audit trail of all actions taken on a process, including task completions, comments, status changes, assignments, and system events. This endpoint is essential for compliance, auditing, and building custom activity dashboards. :::note[No direct CSV export] While the UI doesn't offer CSV export for activity feeds, this API endpoint provides complete access to all activity data that can be exported programmatically in any format you need. ::: ## Endpoint `GET /organizations/{org}/activity-feeds` ## Request ### Headers - `Authorization: Bearer {your_access_token}` - Required - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Query Parameters | Parameter | Type | Required | Description | Example | |-----------|------|----------|-------------|---------| | `entity_type` | string | Yes* | Type of entity to filter | `run` for processes | | `entity_id` | string | Yes* | ID of the specific process | `abc123` | | `type` | string | No | Filter by activity type | `Task`, `Comment`, `Process` | | `verb` | string | No | Filter by action performed | `completed`, `commented`, `updated` | | `actor_type` | string | No | Filter by who performed action | `user`, `guest` | | `actor_id` | integer | No | ID of specific user/guest | `12345` | | `source` | string | No | Source of activity | `Member`, `Guest`, `Webhook` | | `page` | integer | No | Page number for pagination | Default: `1` | | `per_page` | integer | No | Items per page (max 100) | Default: `20` | | `sort` | string | No | Sort order | `-created_at` (newest first) | *Required when fetching activities for a specific process ### Common Verb Values - `created` - Entity was created - `updated` - Entity was modified - `completed` - Task or step was completed - `commented` - Comment was added - `assigned` - Task was assigned - `unassigned` - Assignment was removed - `archived` - Entity was archived - `activated` - Entity was activated - `deleted` - Entity was deleted - `reopened` - Task was reopened - `started` - Process or task was started ## Code Samples ## Response ### Success Response (200 OK) ```json { "data": [ { "id": "feed_abc123", "organization_id": "org_xyz", "verb": "completed", "source": "Member", "actor": { "id": 12345, "name": "John Smith", "email": "john@example.com", "type": "user" }, "auditable_type": "task", "auditable_id": "task_456", "parentable_type": "run", "parentable_id": "run_789", "type": "Task", "description": "Completed task: Review document", "field": null, "old_value": null, "created_at": "2025-03-15T10:30:00Z", "text": null, "references": [], "audit": { "id": "task_456", "name": "Review document", "status": "completed", "completed_at": "2025-03-15T10:30:00Z", "completed_by": 12345 }, "parent": { "id": "run_789", "name": "Employee Onboarding - Jane Doe", "status": "active" } }, { "id": "feed_def456", "organization_id": "org_xyz", "verb": "commented", "source": "Guest", "actor": { "id": 67890, "name": "External Reviewer", "email": "reviewer@external.com", "type": "guest" }, "auditable_type": "task", "auditable_id": "task_456", "parentable_type": "run", "parentable_id": "run_789", "type": "Comment", "description": "Added comment on task", "field": null, "old_value": null, "created_at": "2025-03-15T09:15:00Z", "text": "Document looks good, approved for next step", "references": [], "audit": null, "parent": { "id": "run_789", "name": "Employee Onboarding - Jane Doe", "status": "active" } }, { "id": "feed_ghi789", "organization_id": "org_xyz", "verb": "updated", "source": "Member", "actor": { "id": 12345, "name": "John Smith", "email": "john@example.com", "type": "user" }, "auditable_type": "task", "auditable_id": "task_123", "parentable_type": "run", "parentable_id": "run_789", "type": "Task", "description": "Updated deadline", "field": "deadline", "old_value": "2025-03-20T00:00:00Z", "created_at": "2025-03-15T08:00:00Z", "text": null, "references": [], "audit": { "id": "task_123", "name": "Prepare workspace", "deadline": "2025-03-25T00:00:00Z" }, "parent": { "id": "run_789", "name": "Employee Onboarding - Jane Doe", "status": "active" } } ], "total": 145, "per_page": 20, "current_page": 1, "last_page": 8, "from": 1, "to": 20 } ``` ### Response Fields - **data**: Array of activity objects - **total**: Total number of activities matching the filters - **per_page**: Number of items per page - **current_page**: Current page number - **last_page**: Total number of pages - **from**: Starting item number - **to**: Ending item number ### Activity Object Fields - **id**: Unique activity feed ID - **organization_id**: Organization ID - **verb**: Action performed (completed, updated, commented, etc.) - **source**: Who triggered the activity (Member, Guest, Webhook, System) - **actor**: Object containing details about who performed the action - **auditable_type**: Type of entity that was acted upon (task, step, run, etc.) - **auditable_id**: ID of the entity that was acted upon - **parentable_type**: Type of parent entity - **parentable_id**: ID of parent entity - **type**: Category of activity (Task, Comment, Process, etc.) - **description**: Human-readable description of the activity - **field**: For updates, which field was changed - **old_value**: For updates, the previous value - **created_at**: Timestamp when the activity occurred - **text**: Additional text/content (e.g., comment text) - **references**: Array of related references - **audit**: Current state of the audited object - **parent**: Information about the parent object ## Common Use Cases ### 1. Export Complete Audit Log Fetch all activities for a process and export to your preferred format: ```javascript // Fetch all pages of activities async function exportAuditLog(processId) { let allActivities = []; let page = 1; let hasMore = true; while (hasMore) { const params = new URLSearchParams({ entity_type: 'run', entity_id: processId, page: page.toString(), per_page: '100', sort: '-created_at' }); const response = await fetch( `https://api.tallyfy.com/organizations/${orgId}/activity-feeds?${params}`, { headers: { 'Authorization': `Bearer ${token}` } } ); const data = await response.json(); allActivities = allActivities.concat(data.data); hasMore = data.current_page < data.last_page; page++; } return allActivities; } ``` ### 2. Monitor Real-Time Process Changes Poll for new activities since last check: ```javascript let lastCheckTime = new Date().toISOString(); async function getRecentActivities(processId) { const params = new URLSearchParams({ entity_type: 'run', entity_id: processId, per_page: '20', sort: '-created_at' }); const response = await fetch( `https://api.tallyfy.com/organizations/${orgId}/activity-feeds?${params}`, { headers: { 'Authorization': `Bearer ${token}` } } ); const data = await response.json(); // Filter activities newer than last check const newActivities = data.data.filter( activity => new Date(activity.created_at) > new Date(lastCheckTime) ); if (newActivities.length > 0) { lastCheckTime = newActivities[0].created_at; } return newActivities; } ``` ### 3. Track User Productivity Get all activities by a specific user: ```javascript async function getUserActivities(userId, startDate, endDate) { const params = new URLSearchParams({ actor_type: 'user', actor_id: userId.toString(), per_page: '100', sort: '-created_at' }); const response = await fetch( `https://api.tallyfy.com/organizations/${orgId}/activity-feeds?${params}`, { headers: { 'Authorization': `Bearer ${token}` } } ); return response.json(); } ``` ### 4. Compliance Reporting Generate compliance reports showing all changes to sensitive processes: ```javascript async function getComplianceData(processId) { // Get all updates and completions const params = new URLSearchParams({ entity_type: 'run', entity_id: processId, per_page: '100' }); const response = await fetch( `https://api.tallyfy.com/organizations/${orgId}/activity-feeds?${params}`, { headers: { 'Authorization': `Bearer ${token}` } } ); const data = await response.json(); // Filter for compliance-relevant activities return data.data.filter(activity => ['completed', 'updated', 'assigned', 'unassigned'].includes(activity.verb) || activity.type === 'Comment' ); } ``` ## Error Responses ### 401 Unauthorized ```json { "error": "Unauthorized", "message": "Invalid or expired access token" } ``` ### 403 Forbidden ```json { "error": "Forbidden", "message": "You don't have permission to view this process's activities" } ``` ### 404 Not Found ```json { "error": "Not Found", "message": "Process not found or has been deleted" } ``` ### 429 Rate Limited ```json { "error": "Too Many Requests", "message": "Rate limit exceeded. Please wait before making more requests" } ``` ## Permissions To access activity feeds, the authenticated user must have one of the following: - Be an administrator in the organization - Have `PROCESS_READ` permission for the specific process - Be the creator of the process - Be assigned to at least one task in the process - Be a support user with appropriate access ## Rate Limits - Default rate limit: 1000 requests per hour per organization - Burst limit: 100 requests per minute - Use pagination and caching to minimize API calls - **[Get process](https://tallyfy.com/products/pro/integrations/open-api/code-samples/processes/get-process/)**: This API endpoint retrieves comprehensive details about a specific Tallyfy process run using its unique ID and supports optional query parameters to include related data like tasks and form field values along with a special next_task parameter that returns the first visible incomplete task in the process. ## Endpoint `GET /organizations/{org_id}/runs/{run_id}` This endpoint retrieves the full details for a single Tallyfy process instance (run) identified by its unique ID. ## Request Replace `{org_id}` with your Organization ID and `{run_id}` with the specific ID of the process run you want to retrieve. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Query parameters (optional) - `with` (string): A comma-separated list to include related data (e.g., `checklist`, `tasks`, `tags`, `assets`, `next_task`, `tasks.step`, `tasks.threads`, `form_fields`, `ko_form_fields`). - `form_fields_values` (boolean, e.g., `true`): Include the values submitted to form fields. #### Understanding `with=next_task` When you include `next_task` in the `with` parameter, the API returns information about the next task that needs attention in the process. **What does `next_task` return?** - The first visible incomplete task ordered by position number - **Visible** means not hidden/auto-skipped by automation rules - **Incomplete** means not yet completed (includes tasks currently in-progress) - **Ordered by position** means task 1, task 2, task 3, etc. - Returns `null` if all tasks in the process are completed **When to use it:** - Determining which task to display to the user next - Automating assignments or notifications for upcoming tasks - Building custom dashboards that show current process status - Integration logic that needs to know what's pending **Example response snippet:** ```json { "data": { "id": "run123", "name": "Customer Onboarding", "next_task": { "id": "task456", "title": "Review Application", "position": 3, "status": "not-started", "deadline": "2025-11-25T17:00:00Z" } } } ``` ### Code samples ## Response A successful request returns a `200 OK` status code and a JSON object containing a `data` field with the process run's details. ```json { "data": { "id": "PROCESS_RUN_ID_TO_GET", "increment_id": 5015, "checklist_id": "template_id_abc", "checklist_title": "Client Onboarding V3", "name": "Onboarding - Globex Corp", "summary": "New client onboarding process run.", "status": "active", "progress": { ... }, "started_by": 1002, "owner_id": 1002, "created_at": "2025-05-20T11:00:00Z", "last_updated": "2025-05-21T09:30:00Z", "prerun": { // Kick-off form field values if filled "kickoff_field_id_1": "Globex Corporation", "kickoff_field_id_2": "2025-06-01T00:00:00Z" }, // Included if requested with 'with=checklist' "checklist": { ... template details ... }, // Included if requested with 'with=tasks' "tasks": [ { ... task details ... } ], // Included if requested with 'with=tags' "tags": [ { ... tag details ... } ] // ... other run properties ... } } ``` If the run ID is not found or you lack permission, a `404 Not Found` or `403 Forbidden` error will be returned. --- - **[Launch projects](https://tallyfy.com/products/pro/integrations/open-api/code-samples/processes/launch-process-without-template/)**: Tallyfy enables launching empty processes without predefined templates by using the API's separate_task_for_each_assignee parameter which creates an ad-hoc container for one-off tasks that can be tracked together as a single project - perfect for AI assistants and automation tools that need to create dynamic workflows programmatically. # Launch a process as an "empty shell" - effectively a "project" Normally in Tallyfy - you would create a template and then launch it. Sometimes however you need to launch an ad-hoc project - just a one-time set of tasks and you want to track that just like you track a process. We offer the ability to launch an "empty process" with no tasks in it. This give you then ability to then add one-off tasks to it and track it just like a process. To put it more simply - Tallyfy offers the ability to run simple one-off projects, not just repeatable processes from a pre-made template. Here's how you can launch a process without requiring a predefined template. This powerful feature enables AI assistants, automation tools, and integrations to create ad-hoc collections of tasks that are tracked together as a single process. ## Overview Tallyfy's API supports creating processes without templates through a special parameter in the task creation endpoint. When you set `separate_task_for_each_assignee: true`, the system automatically: 1. Creates an empty process (using the internal MISC system template) 2. Creates individual tasks for each assignee 3. Links all tasks to the same process for unified tracking This eliminates the need to create templates for one-time or dynamic processes. ## API endpoint ``` POST /api/organizations/{orgId}/tasks ``` ### Required Headers ```http Authorization: Bearer {access_token} Content-Type: application/json ``` ## Key parameter The magic happens with this single parameter: ```json { "separate_task_for_each_assignee": true } ``` When set to `true`, this parameter triggers the creation of an empty process container that holds all the tasks. ## Request schema ### Complete request body ```json { "title": "Task title", "summary": "Optional task description", "owners": { "users": ["userId1", "userId2", "userId3"], "guests": ["guest@example.com"], "groups": ["groupId1"] }, "separate_task_for_each_assignee": true, "task_type": "task", "deadline": "YYYY-MM-DD 17:00:00", "everyone_must_complete": false, "is_soft_start_date": true, "started_at": "YYYY-MM-DD 09:00:00", "prevent_guest_comment": false, "can_complete_only_assignees": false, "max_assignable": 0, "webhook": "https://your-webhook.com/endpoint", "tags": ["tagId1", "tagId2"], "top_secret": false, "form_fields": [ { "label": "Project Name", "field_type": "text", "required": true, "guidance": "Enter the project name", "position": 1 } ] } ``` ### Parameter details | Parameter | Type | Required | Description | |-----------|------|----------|-------------| | `title` | string | Yes | Title for the process and all tasks (max 600 characters) | | `summary` | string | No | Description or instructions for the tasks | | `owners` | object | Yes | Contains arrays of users, guests, and/or groups | | `separate_task_for_each_assignee` | boolean | Yes | Must be `true` to create process without template | | `task_type` | string | Yes | Type of task: "task", "approval", "expiring", "email", or "expiring_email" | | `deadline` | string | Yes | Deadline in "YYYY-MM-DD HH:MM:SS" format | | `everyone_must_complete` | boolean | No | Set to `false` for independent task completion (default: false) | | `is_soft_start_date` | boolean | No | Whether the start date is flexible (default: false) | | `started_at` | string | No | Start date in "YYYY-MM-DD HH:MM:SS" format (defaults to current time) | | `prevent_guest_comment` | boolean | No | Prevent guests from commenting (default: false) | | `can_complete_only_assignees` | boolean | No | Only assignees can complete the task (default: false) | | `max_assignable` | integer | No | Maximum number of assignees (default: 0, meaning unlimited) | | `webhook` | string | No | URL for webhook notifications on task events | | `tags` | array | No | Array of tag IDs (32-character strings) | | `top_secret` | boolean | No | Mark task as confidential (default: false) | | `form_fields` | array | No | Array of form field definitions for data collection | ### Form fields structure When including `form_fields`, each field object must contain: | Field Property | Type | Required | Description | |----------------|------|----------|-------------| | `label` | string | Yes | Display label for the form field | | `field_type` | string | Yes | Type of field: "text", "textarea", "radio", "dropdown", "multiselect", "number", "email", "url", "date", "time", "datetime", "checkbox", "file" | | `required` | boolean | Yes | Whether the field is mandatory | | `options` | array | Conditional | Required for "radio", "dropdown", and "multiselect" field types | | `guidance` | string | No | Help text for the field | | `position` | integer | No | Display order of the field | **Important Notes:** - Guest assignees must be email addresses, not IDs - The API returns only the first created task, but creates tasks for all assignees - When groups are specified, tasks are created for each member of the group - The process uses a system "MISC" template that exists in every organization ## Implementation examples ## Advanced usage ### Creating multi-stage processes For processes that require different tasks with unique titles and descriptions, use a two-stage approach: 1. **Stage 1**: Create the first task with `separate_task_for_each_assignee: true` to establish the process 2. **Stage 2**: Add additional tasks to the same process using the `run_id` from Stage 1 ## Use cases ### 1. AI assistant bulk operations Perfect for AI assistants that need to create tasks for multiple users: ```javascript // AI Assistant: "Ask 6 people to submit timesheets by Friday 5pm" const timesheetRequest = { title: "Submit Weekly Timesheet", userIds: ["user1", "user2", "user3", "user4", "user5", "user6"], description: "Please submit your timesheet for this week", deadline: getDeadline(5) // 5 days from now }; await createProcessWithoutTemplate(orgId, token, timesheetRequest); // Creates 1 process with 6 individual tasks, each trackable separately ``` ### 2. Dynamic approval workflows Create approval chains without predefined templates: ```python # Dynamic approval chain based on document type approval_chain = determine_approval_chain(document_type) # Returns user IDs creator.create_process_without_template( title=f"Approve {document_type}", user_ids=approval_chain, description=f"Please review and approve the {document_type}", deadline=datetime.now() + timedelta(days=3) ) ``` ### 3. Event-driven task creation Respond to external events by creating processes: ```javascript // Webhook receives new customer signup async function onNewCustomer(customerData) { const onboardingTasks = { title: `Onboard ${customerData.company}`, userIds: [ salesRepId, // Welcome call supportRepId, // Setup assistance successManagerId // Success planning ], description: `Complete onboarding for new customer: ${customerData.company}`, deadline: getDeadline(7) // 7 days from now }; await createProcessWithoutTemplate(orgId, token, onboardingTasks); } ``` ### 4. Batch processing from spreadsheets Import tasks from external sources: ```python import pandas as pd # Read tasks from CSV df = pd.read_csv('monthly_tasks.csv') for _, row in df.iterrows(): creator.create_process_without_template( title=row['task_title'], user_ids=row['assignees'].split(','), description=row['description'], deadline=datetime.strptime(row['due_date'], '%Y-%m-%d') ) ``` ## API response The API returns a single task object (the first task created) even though it creates tasks for all assignees. The response includes: ```json { "data": { "id": "task_id", "title": "Task title", "status": "not-started", "deadline": "YYYY-MM-DD 17:00:00", "run": { "id": "process_id", "name": "Task title", "permalink": "https://app.tallyfy.com/...", "started_at": "YYYY-MM-DD 09:00:00" } } } ``` To track all created tasks, you'll need to query the process using the returned `run.id`. ## Important considerations ## Error handling Always implement proper error handling for production use: ```javascript try { const result = await createProcessWithoutTemplate(orgId, token, taskData); // Log success console.log(`Process created: ${result.data.run.id}`); // Store process ID for tracking await storeProcessId(result.data.run.id); } catch (error) { // Handle specific error types if (error.status === 401) { // Token expired, refresh and retry await refreshToken(); return retry(); } else if (error.status === 422) { // Validation error console.error('Invalid task data:', error.response.errors); } else if (error.status === 429) { // Rate limited, wait and retry await sleep(60000); return retry(); } else { // Log unexpected errors console.error('Unexpected error:', error); throw error; } } ``` ## Testing your implementation Use our test script to verify your implementation: ```bash # Download test script curl -O https://docs.tallyfy.com/examples/test_process_without_template.py # Set environment variables # Run tests python3 test_process_without_template.py ``` ## Best practices 1. **Use Descriptive Titles**: Since these processes don't have templates, make titles clear and actionable 2. **Include Context in Descriptions**: Provide sufficient context in the `summary` field 3. **Set Realistic Deadlines**: Consider timezone differences and working hours 4. **Track Process IDs**: Store returned process IDs for monitoring and reporting 5. **Implement Retry Logic**: Handle transient failures gracefully 6. **Log All Operations**: Maintain audit trails for compliance and debugging - **[Launch process](https://tallyfy.com/products/pro/integrations/open-api/code-samples/processes/launch-process/)**: The API endpoint POST /organizations/{org_id}/runs launches new Tallyfy process instances from templates by specifying required fields like checklist_id and name along with optional parameters for pre-filling kick-off forms and overriding task assignments and deadlines. ## Launch process API endpoint This endpoint launches a new Tallyfy process instance (run) based on a specified template (checklist/blueprint). :::note[API vs UI Terminology] Note the terminology difference: - In the Tallyfy UI: **Template** → **Process** - In the API: **Blueprint/Checklist** → **Run** ::: ## Endpoint `POST /organizations/{org_id}/runs` ## Request Replace `{org_id}` with your Organization ID. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` - `Content-Type: application/json` ### Body (JSON) The request body requires a JSON object containing the details for the new Tallyfy process run. **Required Fields:** - `checklist_id` (string): The ID of the template (blueprint) to launch from. - `name` (string): The name for this specific process instance. **Optional Fields (Refer to `#definitions/createRunInput` in Swagger):** - `summary` (string): Description for this process instance. - `owner_id` (integer): User ID of the process owner. - `is_public` (boolean): Make the process accessible via a public link. - `parent_id` (string): Link this process as a sub-process of another run. - `prerun` (array): An array of objects to pre-fill kick-off form fields. The structure depends on the field type (see examples below). - `tasks` (object): Define overrides for task properties like assignees and deadlines for specific steps within this run. Keys are Step IDs from the template. - `tags` (array of strings): Tag IDs to apply to this process instance. - `users` (array of integers): User IDs assigned to the process. - `groups` (array of strings): Group IDs assigned to the process. - `roles` (array of objects): Role assignments (structure defined in Swagger). - `folders` (array of strings): Folder IDs where this process should appear. ### Populating kick-off fields using `prerun` The `prerun` array takes objects where the key is the **Kick-off Field ID (Prerun ID)** from your Tallyfy template and the value depends on the field type: - **Text/Textarea:** `{ "field_id_abc": "Your text value" }` - **Date:** `{ "field_id_def": "YYYY-MM-DDTHH:mm:ss.sssZ" }` (ISO 8601 format) - **Radio Button:** `{ "field_id_ghi": "Selected Radio Option Value" }` - **Dropdown:** `{ "field_id_jkl": { "id": 2, "text": "Selected Option Text", "value": null } }` (Provide the option object as defined in the template) - **Checklist (Multi-select):** `{ "field_id_mno": [{ "id": 1, "text": "Option 1 Text", "value": null, "selected": true }, { "id": 3, "text": "Option 3 Text", "value": null, "selected": true }] }` (Array of selected option objects) - **File/Image:** `{ "field_id_pqr": [{ "id": "asset_id_123", "filename": "report.pdf", "version": 1, "url": "...", "uploaded_from": "ko_field", "subject": { "id": "template_id", "type": "Checklist" } }] }` (Requires pre-uploading the file and using the returned asset object) ### Overriding task properties using `tasks` The `tasks` object allows specifying assignees and deadlines per step for this specific run. The key is the **Step ID** from the template. :::note[Task Assignment Precedence] 1. Assignees defined in the `tasks` object of the launch request override template step assignees. 2. If not specified in the request, assignees defined on the template step are used. 3. If no assignees are defined anywhere, the task assignment depends on the step's `assign_run_starter` setting (defaults to `true` if not set, meaning the launcher gets assigned). Set it to `false` and provide empty assignee arrays (`users`, `groups`, `guests`) to ensure a task starts unassigned. ::: ## Code Samples ## Response A successful request returns a `200 OK` status code and a JSON object containing the full details of the newly created Tallyfy process instance. - **[List processes](https://tallyfy.com/products/pro/integrations/open-api/code-samples/processes/list-processes/)**: This documentation explains how to retrieve and filter process instances within a Tallyfy organization using a GET API endpoint that supports various query parameters for searching by status owners templates tags and other criteria with code examples in multiple programming languages including JavaScript Python Java Go C++ and C#. ## Endpoint `GET /organizations/{org_id}/runs` This endpoint retrieves a list of Tallyfy process instances (runs) within your organization. It supports extensive filtering through query parameters. ## Request Replace `{org_id}` with your actual Organization ID. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Query parameters (optional) This endpoint offers several parameters to filter Tallyfy process results. Refer to the `GET /organizations/{org}/runs` definition in Swagger for the full list. Common parameters include: - `q` (string): Search term for process name. - `status` (string): Filter by status (e.g., `active`, `problem`, `delayed`, `complete`, `archived`). - `owners` (string): Comma-separated list of User IDs to filter by process owner. - `checklist_id` (string): Filter processes launched from a specific template ID. - `folder` (string): Filter processes within a specific folder ID. - `tag` (string): Filter processes by a specific Tag ID. - `starred` (boolean): Filter by starred status. - `type` (string): Filter by type (e.g., `procedure`, `form`). - `groups` (string): Comma-separated list of Group IDs involved in tasks within the process. - `task_status` (string): Filter processes based on the status of tasks within them (e.g., `in-progress`, `completed`). - `with` (string): Comma-separated list to include related data (e.g., `checklist`, `tasks`, `tags`, `assets`). - `page` (integer): For pagination, the page number to retrieve (default: 1). - `per_page` (integer): For pagination, the number of results per page (default: 10). - `sort` (string): Field to sort by (e.g., `name`, `created_at`, `-created_at` for descending). ### Code samples ## Response A successful request returns a `200 OK` status code and a JSON object containing a `data` array. Each element in the array represents a process run matching the filter criteria. ```json { "data": [ { "id": "run_id_abc", "increment_id": 5012, "checklist_id": "template_id_123", "checklist_title": "Customer Onboarding", "name": "Onboarding - ACME Corp", "summary": "Process instance for ACME.", "status": "active", "progress": { "complete": 5, "total": 10, "percent": 50 }, "started_by": 1001, "created_at": "2025-01-15T10:00:00.000Z", "last_updated": "2025-01-17T15:30:00.000Z", "due_date": "2025-02-15T10:00:00.000Z", "owner_id": 1001, // ... other run properties ... }, { "id": "run_id_def", // ... details for another process run ... } ], "meta": { "pagination": { "total": 55, "count": 10, "per_page": 10, "current_page": 1, "total_pages": 6, "links": { "next": "https://go.tallyfy.com/api/organizations/{org_id}/runs?status=active&per_page=10&page=2" } } } } ``` The `meta.pagination` object provides details for navigating through multiple pages of results if applicable. --- - **[Update process](https://tallyfy.com/products/pro/integrations/open-api/code-samples/processes/update-process/)**: The PUT endpoint allows modification of existing Tallyfy process instance properties like name summary owner tags and folders where providing arrays for tags or folders completely replaces the existing values rather than appending to them. ## Endpoint `PUT /organizations/{org_id}/runs/{run_id}` This endpoint allows you to update certain properties of an existing Tallyfy process instance (run). ## Request Replace `{org_id}` with your Organization ID and `{run_id}` with the ID of the process run to update. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` - `Content-Type: application/json` ### Body (JSON) The request body requires a JSON object containing the process properties you wish to modify. You only need to include the fields you want to change. Refer to the `#definitions/createRunInput` schema (often similar for updates) in Swagger. Common updatable fields include: - `name` (string): New name for the process instance. - `summary` (string): New summary/description. - `owner_id` (integer): Change the process owner. - `tags` (array of strings): **Replaces** the current list of tag IDs associated with the process. - `folders` (array of strings): **Replaces** the current list of folder IDs. - `prerun` (array): Update kick-off form field values (structure depends on field type, see [Launch Process](/products/pro/integrations/open-api/code-samples/processes/launch-process/)). - `prevent_guest_comment` (boolean): Enable/disable guest comments. ### Updating form fields using `taskdata` To update form field values, include a `taskdata` object in the request body. The keys within `taskdata` are the **Form Field IDs (Capture IDs)**, and the values depend on the field type: :::note[Updating Tasks within a Process] To update individual tasks (assignees, deadlines, form fields) within a running process, use the [Update Task](/products/pro/integrations/open-api/code-samples/tasks/update-task/) endpoint (`PUT /organizations/{org}/runs/{run_id}/tasks/{task_id}`) instead. ::: :::caution[Replacing Arrays (Tags/Folders)] Providing the `owners` object *replaces* all existing assignees with the ones specified in the `users`, `groups`, and `guests` arrays within the object. To remove all assignees, provide empty arrays for all three. ::: **Example Body:** ```json { "name": "Onboarding - Globex Corp (Updated)", "summary": "Updated summary notes for this run.", "tags": ["tag_id_urgent", "tag_id_onboarding"], "prevent_guest_comment": true } ``` ## Code Samples ## Response A successful request returns a `200 OK` status code and a JSON object containing the full details of the process run *after* the update. ```json { "data": { "id": "PROCESS_RUN_ID_TO_UPDATE", "name": "Onboarding - Globex Corp (Updated)", // Updated name "summary": "Updated summary notes for this run.", // Updated summary "tags": ["tag_id_urgent", "tag_id_onboarding"], // Updated tags // ... other process properties reflecting the current state ... "last_updated": "YYYY-MM-DDTHH:MM:SSZ", // Timestamp reflects the update "notes": "Updated process notes." } } ``` If the run ID is not found, you lack permission, or the request body is invalid, an appropriate error status code (`404`, `403`, `400`, `422`) will be returned. --- ### Tags - **[Archive tag](https://tallyfy.com/products/pro/integrations/open-api/code-samples/tags/archive-tag/)**: This endpoint performs a soft delete on a tag by archiving it rather than permanently removing it from the system and returns the archived tag details with a deleted_at timestamp upon successful completion. ## Endpoint `DELETE /organizations/{org_id}/tags/{tag_id}` This endpoint archives (soft deletes) an existing tag. Archived tags are generally hidden but not permanently removed. ## Request Replace `{org_id}` with your Organization ID and `{tag_id}` with the ID of the tag to archive. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Body No request body is needed for this DELETE request. ### Code samples ## Response A successful archive request typically returns a `200 OK` status code. The response body usually contains the details of the archived tag, now including a `deleted_at` timestamp. ```json { "data": { "id": "TAG_ID_TO_ARCHIVE", "title": "Old Tag Name", "color": "#cccccc", // ... other tag properties ... "deleted_at": "2025-05-21T21:00:00Z" // Timestamp indicates archival } } ``` If the tag ID is not found, an error will be returned. --- - **[Create tag](https://tallyfy.com/products/pro/integrations/open-api/code-samples/tags/create-tag/)**: This documentation explains how to create a new tag within an organization using a POST API endpoint by providing a required title and optional hex color code in the request body with code examples available in JavaScript Python Java Go C++ and C#. ## Endpoint `POST /organizations/{org_id}/tags` This endpoint creates a new tag within the specified organization. ## Request Replace `{org_id}` with your Organization ID. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` - `Content-Type: application/json` ### Body (JSON) The request body requires a JSON object defining the new tag. Refer to the `#definitions/createTagInput` schema in Swagger. Key fields: - `title` (string, required): The name of the tag. - `color` (string, optional): A hex color code (e.g., `#3498db`) for the tag. **Example Body:** ```json { "title": "High Priority", "color": "#e74c3c" } ``` ## Code samples ## Response A successful request returns a `200 OK` or `201 Created` status code and a JSON object containing the details of the newly created tag, including its assigned `id`. ```json { "data": { "id": "new_tag_id_xyz", "title": "Python Tag", "color": "#f1c40f", "template": 0, "active_process": 0, "auto_generated": false, "created_at": "YYYY-MM-DDTHH:MM:SSZ", "deleted_at": null } } ``` Make note of the returned `id` to manage this tag later. --- - **[Get tag](https://tallyfy.com/products/pro/integrations/open-api/code-samples/tags/get-tag/)**: This API endpoint retrieves detailed information about a specific tag in an organization by its unique ID and supports optional parameters to include additional data like usage statistics. ## Endpoint `GET /organizations/{org_id}/tags/{tag_id}` This endpoint retrieves the details for a single tag identified by its unique ID. ## Request Replace `{org_id}` with your Organization ID and `{tag_id}` with the specific ID of the tag you want to retrieve. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Query parameters (optional) - `with` (string): Include additional related data, e.g., `statistics`. ### Code samples ## Response A successful request returns a `200 OK` status code and a JSON object containing a `data` field with the tag's details. ```json { "data": { "id": "TAG_ID_TO_GET", "title": "Urgent", "color": "#e74c3c", "template": 5, "active_process": 12, "auto_generated": false, "created_at": "2024-01-15T10:00:00Z", "deleted_at": null, // Included if requested with 'with=statistics' "statistics": { // ... detailed usage counts ... } } } ``` If the tag ID is not found or you lack permission, a `404 Not Found` or `403 Forbidden` error will be returned. --- - **[List tags](https://tallyfy.com/products/pro/integrations/open-api/code-samples/tags/list-tags/)**: This endpoint retrieves all tags within an organization by making a GET request with optional query parameters for searching filtering and pagination while returning tag details like ID title color usage counts and creation timestamps in a JSON response. ## Endpoint `GET /organizations/{org_id}/tags` This endpoint retrieves a list of tags available within the specified organization. ## Request Replace `{org_id}` with your Organization ID. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Query parameters (optional) Refer to Swagger for filtering options, which might include: - `q` (string): Search by tag title. - `with` (string): Include related data (e.g., `statistics`). - Pagination parameters (`page`, `per_page`). - Sorting parameters (`sort`). ### Code samples ## Response A successful request returns a `200 OK` status code and a JSON object containing a `data` array. Each element represents a tag. ```json { "data": [ { "id": "tag_id_abc", // Unique tag ID "title": "Urgent", "color": "#e74c3c", // Hex color code "template": 5, // Count of templates using this tag "active_process": 12, // Count of active processes using this tag "auto_generated": false, "created_at": "2025-01-15T10:00:00Z", "deleted_at": null, // Included if requested with 'with=statistics' "statistics": { // ... detailed usage counts ... } }, { "id": "tag_id_def", "title": "Finance", "color": "#2ecc71", // ... other tag details ... } ], "meta": { // Pagination details if applicable } } ``` --- - **[Update tag](https://tallyfy.com/products/pro/integrations/open-api/code-samples/tags/update-tag/)**: This API reference explains how to modify an existing tag's properties such as title and color by sending a PUT request with JSON data containing the updated values to the specified organization and tag endpoint. ## Endpoint `PUT /organizations/{org_id}/tags/{tag_id}` This endpoint updates the properties (like title or color) of an existing tag. ## Request Replace `{org_id}` with your Organization ID and `{tag_id}` with the ID of the tag to update. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` - `Content-Type: application/json` ### Body (JSON) The request body requires a JSON object containing the tag properties to modify. Refer to the `#definitions/createTagInput` schema (often similar to update). Key fields: - `title` (string): New title for the tag. - `color` (string): New hex color code. **Example Body:** ```json { "title": "High Priority (Red)", "color": "#ff0000" } ``` ## Code Samples ## Response A successful request returns a `200 OK` status code and a JSON object containing the full details of the tag *after* the update. ```json { "data": { "id": "TAG_ID_TO_UPDATE", "title": "Python Updated Tag", // Updated title "color": "#34495e", // Updated color // ... other tag properties ... "updated_at": "YYYY-MM-DDTHH:MM:SSZ" // Reflects update time } } ``` If the tag ID is not found or the payload is invalid, an error status code (`404`, `400`, `422`) will be returned. --- ### Guests - **[Create guest](https://tallyfy.com/products/pro/integrations/open-api/code-samples/guests/create-guest/)**: This API endpoint creates new guest user records within a Tallyfy organization by sending a POST request with required email address and optional details like name and company information then returning the created guest data or an error if the email already exists. ## Endpoint `POST /organizations/{org_id}/guests` This endpoint creates a new guest user record within the specified Tallyfy organization. ## Request Replace `{org_id}` with your Organization ID. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` - `Content-Type: application/json` ### Body (JSON) The request body requires a JSON object containing the details of the guest to be created in Tallyfy. Refer to the `#definitions/createGuestInput` schema in Swagger for all available properties. Key fields include: - `email` (string, required): The guest's email address (must be unique within the organization's guests). - `first_name` (string, optional) - `last_name` (string, optional) - `phone_1` (string, optional) - `company_name` (string, optional) - `timezone` (string, optional): E.g., `Europe/Paris`. - `associated_members` (array of integers, optional): User IDs of members associated with this guest. **Minimal Example Body:** ```json { "email": "new.guest@contractor.com" } ``` **More Comprehensive Example Body:** ```json { "email": "client.contact@acme.com", "first_name": "Client", "last_name": "Contact", "company_name": "ACME Corp", "phone_1": "+1-212-555-0123", "associated_members": [1001, 1005] } ``` ### Code samples ## Response A successful request returns a `200 OK` or `201 Created` status code and a JSON object containing the details of the newly created guest. ```json { "data": { "id": "new_guest_code_789", // Unique ID for this guest "email": "external.partner@partnerco.com", "last_accessed_at": null, "details": { "first_name": "External", "last_name": "Partner", "status": "active", "company_name": "Partner Co", // ... other details provided or defaulted ... "created_at": "...", // Timestamp when guest was created "updated_at": "..." // Timestamp when guest was last updated } } } ``` If a guest with the provided email already exists, you will likely receive a `422 Unprocessable Entity` error. --- - **[Delete guest](https://tallyfy.com/products/pro/integrations/open-api/code-samples/guests/delete-guest/)**: A DELETE endpoint that removes guest users from an organization by their email address and returns either a success status code or guest record details upon completion. ## Endpoint `DELETE /organizations/{org_id}/guests/{guest_email}` This endpoint removes a guest user record from your Tallyfy organization, identified by their email address. This action prevents the guest from accessing any further tasks or information within this organization. :::note[Alternative Endpoint] The Swagger specification also lists `DELETE /organizations/{org}/guests/{guestID}/delete`. This suggests you might also be able to delete a guest using their unique ID (`guest_code`) instead of their email. Check the specific endpoint behavior if needed. ::: ## Request Replace `{org_id}` with your Organization ID and `{guest_email}` with the URL-encoded email address of the guest to remove. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Body No request body is needed for this DELETE request. ### Code samples ## Response A successful deletion might return `201 Created`, `200 OK`, or `204 No Content`. - If `201` or `200`, the body might contain the details of the deleted guest record. - If `204`, there is no response body. If the guest email is not found in your Tallyfy organization, a `404 Not Found` error will be returned. --- - **[Get guest](https://tallyfy.com/products/pro/integrations/open-api/code-samples/guests/get-guest/)**: This endpoint retrieves specific guest user details from a Tallyfy organization by making a GET request with the guest's URL-encoded email address and optional query parameters for including related data like statistics. ## Endpoint `GET /organizations/{org_id}/guests/{guest_email}` This endpoint retrieves the details for a specific guest user within the Tallyfy organization, identified by their email address. ## Request Replace `{org_id}` with your Organization ID and `{guest_email}` with the URL-encoded email address of the guest you want to retrieve (e.g., `user%40example.com`). ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Query parameters (optional) - `with` (string): Include additional related data, e.g., `stats`. ### Code samples ## Response A successful request returns a `200 OK` or `201 Created` status code and a JSON object containing a `data` field with the guest's details. ```json { "data": { "id": "guest_code_abc123", "email": "guest.to.get@example.com", "last_accessed_at": "2025-05-15T10:00:00Z", "details": { "first_name": "Specific", "last_name": "Guest", "status": "active", "company_name": "Guest Company", // ... other guest details ... }, // Included if requested with 'with=stats' "stats": { ... } } } ``` If the guest email is not found in your Tallyfy organization or you lack permission, you will likely receive a `404 Not Found` or `403 Forbidden` error. --- - **[Update guest](https://tallyfy.com/products/pro/integrations/open-api/code-samples/guests/update-guest/)**: This endpoint enables updating existing guest user information in a Tallyfy organization by sending a PUT request with the guest's URL-encoded email address and a JSON payload containing modifiable fields like name phone and company details. ## Endpoint `PUT /organizations/{org_id}/guests/{guest_email}` This endpoint updates the details for an existing guest user in your Tallyfy organization, identified by their email address. ## Request Replace `{org_id}` with your Organization ID and `{guest_email}` with the URL-encoded email address of the guest to update. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` - `Content-Type: application/json` ### Body (JSON) The request body requires a JSON object containing the guest detail fields you wish to modify. Refer to the `#definitions/createGuestInput` schema in Swagger (often the same as creation) for available fields like: - `first_name` (string) - `last_name` (string) - `phone_1` / `phone_2` (string) - `company_name` (string) - `timezone` (string) - `associated_members` (array of integers) - Note: Check if this replaces or appends. **Example Body:** ```json { "first_name": "UpdatedFirstName", "company_name": "New Company Name Ltd.", "phone_1": "+441234567890" } ``` :::note Changing a guest's email address is typically not possible via this endpoint; you would usually need to delete the old guest record and create a new one. ::: ### Code samples ## Response A successful request returns a `200 OK` status code and a JSON object containing the full details of the guest after the update. ```json { "data": { "id": "guest_code_abc123", "email": "guest.to.update@example.com", "details": { "first_name": "Guesty", // Updated value "last_name": "McGuestface", // Updated value "company_name": "Updated Guest Corp", // Updated value // ... other details ... "updated_at": "2019-09-14T12:30:00Z" // Reflects update time } } } ``` If the guest email is not found in your Tallyfy organization or the payload is invalid, an appropriate error status code (`404`, `400`, `422`) will be returned. --- - **[List guests](https://tallyfy.com/products/pro/integrations/open-api/code-samples/guests/list-guests/)**: This API endpoint retrieves all guest users associated with a Tallyfy organization by making a GET request with proper authorization headers and optional query parameters for pagination and additional statistics data. ## Endpoint `GET /organizations/{org_id}/guests` This endpoint retrieves a list of guest users associated with the specified Tallyfy organization. ## Request Replace `{org_id}` with your Organization ID. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Query parameters (optional) - `with` (string): Include additional data, e.g., `stats`. - Pagination parameters (`page`, `per_page`) may also be available. ### Code samples ## Response A successful request returns a `200 OK` status code and a JSON object containing a `data` array. Each element represents a guest associated with the Tallyfy organization. ```json { "data": [ { "id": "guest_code_abc123", // Unique guest code/identifier "email": "guest.user@external.com", "last_accessed_at": "2025-05-15T10:00:00Z", "last_known_ip": "192.0.2.1", "last_known_country": "US", "details": { "first_name": "External", "last_name": "Collaborator", "status": "active", // Can be active, disabled "phone_1": null, "company_name": "External Inc.", "timezone": "UTC", "disabled_on": null, "disabled_by": null, // ... other detail fields ... }, // Included if requested with 'with=stats' "stats": { "active_tasks": 2, "completed_tasks": 5 // ... other stats ... } }, { "id": "guest_code_def456", "email": "another.guest@domain.com", // ... details ... } ] // Potential meta object for pagination if supported } ``` --- ### Tasks - **[Archive task](https://tallyfy.com/products/pro/integrations/open-api/code-samples/tasks/archive-task/)**: A DELETE endpoint that archives standalone tasks by hiding them from default views while preserving data for potential future restoration through authenticated API requests and returns 200 or 204 status codes upon success. ## Endpoint `DELETE /organizations/{org_id}/tasks/{task_id}` This endpoint archives a standalone ("one-off") Tallyfy task. Archived tasks are hidden from default views but can potentially be restored or deleted permanently later. :::note This endpoint is typically used for **one-off tasks**. To archive tasks within a process run, you usually archive the entire process run using `DELETE /organizations/{org_id}/runs/{run_id}`. ::: ## Request Replace `{org_id}` with your Organization ID and `{task_id}` with the ID of the one-off task to archive. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Body No request body is needed for this DELETE request. ## Code Samples ## Response A successful request returns a `200 OK` status code and a JSON object containing a `data` - **[Complete task](https://tallyfy.com/products/pro/integrations/open-api/code-samples/tasks/complete-task/)**: This documentation explains how to mark Tallyfy tasks as complete using POST requests to different endpoints for process tasks versus one-off tasks with options to include approval status and final form field updates in the request payload. ## Endpoint This endpoint marks a Tallyfy task as complete. The exact endpoint and payload structure differ slightly depending on whether it's a task within a process run or a one-off task: - **Process Task:** `POST /organizations/{org_id}/runs/{run_id}/completed-tasks` - **One-off Task:** `POST /organizations/{org_id}/completed-tasks` Replace `{org_id}`, `{run_id}` (if applicable) with the appropriate IDs. ## Request ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` - `Content-Type: application/json` ### Body (JSON) The request body requires a JSON object specifying the Tallyfy task to complete. **Common Fields:** - `task_id` (string, **required**): The ID of the task to mark as complete. - `is_approved` (boolean, optional): Relevant for approval tasks, set to `true` to approve, `false` to reject. - `taskdata` (object, optional): You can optionally provide final form field values within a `taskdata` object simultaneously with completing the task (same structure as in [Update Task](https://tallyfy.com/products/pro/integrations/open-api/code-samples/tasks/update-task/)). **Example Body (Simple Completion):** ```json { "task_id": "TASK_ID_TO_COMPLETE" } ``` **Example Body (Completion with Final Field Update):** ```json { "task_id": "TASK_ID_TO_COMPLETE", "taskdata": { "final_notes_field_id": "All checks passed." } } ``` **Example Body (Approval Task - Approve):** ```json { "task_id": "APPROVAL_TASK_ID", "is_approved": true } ``` ## Code Samples (Examples use the endpoint for process tasks. Adapt the URL and potentially the payload structure slightly for one-off tasks if needed, based on Swagger definitions `#definitions/CompletedProcessTask` vs the one for one-off tasks). ## Response A successful request returns a `200 OK` status code and a JSON object containing the details of the task, now marked as complete. ```json { "data": { "id": "TASK_ID_TO_COMPLETE", "title": "Review Proposal", "status": "completed", // Status is now complete "completed_at": "2025-05-20T17:00:00.000Z", // Completion timestamp "completer_id": 1001, // User who completed the task (via API token) // ... other task properties, potentially including updated taskdata ... // For process tasks, may include 'tasks_changed_by_rules' if completion triggered rules "tasks_changed_by_rules": {} } } ``` If the task cannot be completed (e.g., already complete, permissions issue, invalid ID), an appropriate error status code will be returned. --- - **[Create one-off task](https://tallyfy.com/products/pro/integrations/open-api/code-samples/tasks/create-task/)**: This endpoint creates standalone one-off tasks in Tallyfy that exist independently from process templates by sending a POST request with task details like name and optional fields such as description and deadline and assignees and tags. ## Endpoint `POST /organizations/{org_id}/tasks` This endpoint creates a new standalone ("one-off") Tallyfy task that is not part of a process run initiated from a template. ## Request Replace `{org_id}` with your Organization ID. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` - `Content-Type: application/json` ### Body (JSON) The request body requires a JSON object defining the new task. Refer to the `#definitions/createStandaloneTaskInput` schema in Swagger for all available properties. Key fields include: - `name` (string, required): The title of the task. - `description` (string): A description or instructions for the task. - `owners` (object): Assignees for the task (structure: `{ "users": [...], "guests": [...], "groups": [...] }`). - `deadline` (string): When work should be **complete** on the task (due date/time in ISO 8601 format). - `started_at` (string): When work should **begin** on the task (start date/time in ISO 8601 format). - `task_type` (string): Usually `member` or `guest`. - `separate_task_for_each_assignee` (boolean): If true, creates individual tasks for each person in `owners`. - `max_assignable` (integer): Maximum number of assignees. - `prevent_guest_comment` (boolean). - `tags` (array of strings): Tag IDs to apply. **Minimal Example Body:** ```json { "name": "Follow up with ACME Corp" } ``` **More Comprehensive Example Body:** ```json { "name": "Prepare Q3 Report", "description": "Gather data and prepare the quarterly report slides.", "owners": { "users": [1001, 1002], "groups": [], "guests": [] }, "deadline": "2025-07-15T17:00:00Z", "tags": ["reporting", "finance"] } ``` ## Code Samples ## Response A successful request returns a `200 OK` or `201 Created` status code and a JSON object containing the details of the newly created Tallyfy one-off task, including its assigned `id`. ```json { "data": { "id": "new_one_off_task_id_789", "increment_id": 1250, "title": "Python One-Off Task: Plan Meeting", "description": "Schedule and plan the project kickoff meeting.", "run_id": null, "step_id": null, "status": "active", "owners": { "users": [ { "id": 1001, "full_name": "Bob", "profile_pic": "..." } ], "guests": [], "groups": [] }, "deadline": null, "created_at": "2025-05-20T18:00:00.000Z", "last_updated": "2025-05-20T18:00:00.000Z" } } ``` Make note of the returned `id` to manage this task later (get, update, complete, delete). --- - **[Delete task](https://tallyfy.com/products/pro/integrations/open-api/code-samples/tasks/delete-task/)**: A DELETE endpoint permanently removes standalone tasks while preserving process-related tasks that can only be deleted through their parent process run deletion. ## Endpoint `DELETE /organizations/{org_id}/tasks/{task_id}/delete` This endpoint permanently deletes a standalone ("one-off") Tallyfy task. This action cannot be undone. :::danger[Irreversible Action] Permanently deleting a task cannot be undone. All associated task data will be lost. Consider archiving unless you are absolutely sure. ::: :::note This endpoint is specifically for **one-off tasks**. To delete tasks within a process run, you typically delete the entire process run using `DELETE /organizations/{org_id}/runs/{run_id}/delete`. ::: ## Request Replace `{org_id}` with your Organization ID and `{task_id}` with the ID of the one-off task to delete permanently. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Body No request body is needed for this DELETE request. ### Code samples ## Response A successful permanent deletion request returns a `204 No Content` status code, and **no response body**. If the task ID doesn't exist, is not a one-off task, or you lack permission, an appropriate error status code (`404`, `403`, `400`) will be returned, potentially with an error message in the response body. --- - **[Get task](https://tallyfy.com/products/pro/integrations/open-api/code-samples/tasks/get-task/)**: This API endpoint retrieves complete details for a specific Tallyfy task by its unique ID and supports optional query parameters to include related data like process run information and form fields while returning a JSON response containing task properties such as title status owners and deadline. ## Endpoint `GET /organizations/{org_id}/tasks/{task_id}` This endpoint retrieves the full details for a single Tallyfy task (either a one-off task or a task within a process run) identified by its unique ID. ## Request Replace `{org_id}` with your Organization ID and `{task_id}` with the specific ID of the task you want to retrieve. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Query parameters (optional) - `with` (string): Include related data. For tasks, common options might include `run`, `step`, `threads`, `assets`, `form_fields`, `tags`, `summary`. Example: `with=run,step,form_fields`. ### Code samples ## Response A successful request returns a `200 OK` status code and a JSON object containing a `data` field. The value of `data` is an object representing the requested task with its full details. ```json { "data": { "id": "TASK_ID_TO_GET", "increment_id": 1205, "title": "Review Proposal", "summary": "Review the proposal document attached.", "run_id": "run_id_xyz", "step_id": "step_id_123", "status": "active", "task_type": "member", // or "guest" "owners": { ... }, "deadline": "YYYY-MM-DDTHH:MM:SSZ", "created_at": "YYYY-MM-DDTHH:MM:SSZ", "last_updated": "YYYY-MM-DDTHH:MM:SSZ", "position": 1, // ... other task properties ... // Included if requested with 'with=form_fields': "form_fields": [ { "id": "capture_id_abc", "label": "Approval Status", "field_type": "dropdown", "value": { "id": 1, "text": "Approved", "value": null }, // Value depends on field type "required": true // ... other form field details ... } ], // Included if requested with 'with=run': "run": { ... process run details ... }, // Included if requested with 'with=step': "step": { ... template step details ... } } } ``` If the task ID is not found or you don't have permission, you will likely receive a `404 Not Found` or `403 Forbidden` error. --- - **[List organization tasks](https://tallyfy.com/products/pro/integrations/open-api/code-samples/tasks/list-org-tasks/)**: The GET endpoint retrieves all tasks across an organization's processes and one-off tasks with extensive filtering options including status assignees deadlines tags folders and pagination while supporting multiple programming languages through code samples that demonstrate query parameter construction and response handling. ## Endpoint `GET /organizations/{org_id}/tasks` This endpoint retrieves a list of all Tallyfy [tasks](/products/pro/tracking-and-tasks/tasks/) across all [processes](/products/pro/tracking-and-tasks/processes/) and one-off tasks within the specified organization. It offers extensive filtering capabilities. ## Request Replace `{org_id}` with your [Organization ID](/products/pro/miscellaneous/how-to-find-your-tallyfy-ids/). ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Query parameters (optional) Refer to the `GET /organizations/{org}/tasks` definition in Swagger for the full list. Key parameters include: - `q` (string): Search by process name or task name. - `status` (string): Filter by task status (e.g., `complete`, `hasproblem`, `overdue`, `due_soon`, `active`, `incomplete`, `inprogress`, `not-started`). - `owners` (string): Comma-separated list of [User IDs](/products/pro/documenting/members/) to filter tasks assigned to *any* of these users. - `guests` (string): Comma-separated list of [Guest emails](/products/pro/documenting/guests/). - `roles` (string): Comma-separated list of [Role IDs](/products/pro/documenting/members/). - `groups` (string): Comma-separated list of [Group IDs](/products/pro/documenting/groups/). - `tag` (string): Filter by [Tag](/products/pro/documenting/templates/how-to-manage-templates-and-processes-with-tags/) name or ID. - `folder` (string): Filter tasks within a specific [folder ID](/products/pro/tracking-and-tasks/tasks-view/how-can-i-add-tasks-to-folders-in-tallyfy/). - `created` (string): Filter by creation date (e.g., `YYYY-MM-DD` or `YYYY-MM-DD:YYYY-MM-DD` range). - `deadline_start_range` / `deadline_end_range` (string): Filter by deadline range (`YYYY-MM-DD`). - `unassigned` (boolean, e.g., `unassigned=true`): **Retrieve only tasks with no assignees.** - `archived` (boolean, e.g., `archived=true`): Include tasks from archived processes. - `with` (string): Include related data (e.g., `run`, `run.checklist`, `step`, `threads`, `assets`, `[form_fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/)`, `tags`). - `page`, `per_page` (integer): For pagination. - `sort` (string): Sort results (e.g., `deadline`, `newest`, `problems`, `-deadline`). - `without_pagination` (boolean, e.g., `without_pagination=true`): Retrieve all results without pagination (use with caution on large datasets). ## Code samples ## Response A successful request returns a `200 OK` status code and a JSON object containing a `data` array of tasks and a `meta` object for pagination. ```json { "data": [ { "id": "task_id_abc", "increment_id": 1205, "title": "Review Proposal", "summary": "Review the proposal document attached.", "run_id": "run_id_xyz", // ID of the process this task belongs to (null for one-off tasks) "step_id": "step_id_123", // ID of the [template step](/products/pro/tracking-and-tasks/tasks/) (null for one-off tasks) "status": "active", "owners": { // Assignees "users": [ { "id": 1001, "full_name": "Alice", "profile_pic": "..." } ], "guests": [], "groups": [] }, "deadline": "YYYY-MM-DDTHH:MM:SSZ", "created_at": "YYYY-MM-DDTHH:MM:SSZ", // ... other task properties (form fields if requested with 'with=form_fields') ... }, // ... more tasks ... ], "meta": { // Pagination details similar to List Processes/Templates "pagination": { ... } } } ``` --- - **[List process tasks](https://tallyfy.com/products/pro/integrations/open-api/code-samples/tasks/list-process-tasks/)**: This endpoint retrieves all tasks belonging to a specific process run by providing the organization ID and run ID with optional query parameters for filtering by status owners deadlines and sorting while returning paginated results containing task details like title position status and related step information. ## Endpoint `GET /organizations/{org_id}/runs/{run_id}/tasks` This endpoint retrieves a list of all Tallyfy tasks specifically associated with a single process instance (run). ## Request Replace `{org_id}` with your Organization ID and `{run_id}` with the ID of the specific process run whose tasks you want to list. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Query parameters (optional) Similar filtering parameters as listing organization tasks are available, but scoped to this process run. Refer to Swagger. - `status` (string): Filter by task status within this run (e.g., `complete`, `active`, `incomplete`, `inprogress`, `not-started`, `hasproblem`, `overdue`, `due_soon`). Note: `auto-skipped` may also appear for tasks hidden by rules. - `owners` (string): Comma-separated User IDs. - `guests` (string): Comma-separated Guest emails. - `groups` (string): Comma-separated Group IDs. - `unassigned` (boolean): Filter for unassigned tasks in this run. - `deadline_start_range` / `deadline_end_range` (string): Filter by deadline. - `with` (string): Include related data (e.g., `step`, `threads`, `assets`, `form_fields`, `summary`). - `page`, `per_page` (integer): Pagination. - `sort` (string): Sort by `position`, `deadline` (or `-position`, `-deadline`). - `without_pagination` (boolean). ### Code samples ## Response A successful request returns a `200 OK` status code and a JSON object containing a `data` array of tasks specific to that process run, and a `meta` object for pagination. ```json { "data": [ { "id": "task_id_1", "increment_id": 1210, "title": "Welcome Call", "run_id": "PROCESS_RUN_ID", "step_id": "step_id_welcome", "status": "active", "position": 1, "owners": { ... }, "deadline": "2025-05-28T17:00:00Z", // ... other task properties ... // Included if requested via 'with=step': "step": { "id": "step_id_welcome", "title": "Schedule Welcome Call", "alias": "welcome_call", // ... other step details ... } }, { "id": "task_id_2", "increment_id": 1211, "title": "Setup Account", "run_id": "PROCESS_RUN_ID", "step_id": "step_id_setup", "status": "not-started", "position": 2, // ... } // ... more tasks from this process run ... ], "meta": { "pagination": { ... } } } ``` --- - **[Reopen task](https://tallyfy.com/products/pro/integrations/open-api/code-samples/tasks/reopen-task/)**: The endpoint allows reopening completed tasks by using DELETE requests to restore them to an active state with proper authentication headers and supports both process-run tasks and standalone one-off tasks through distinct URL patterns. ## Endpoint This endpoint reopens a completed Tallyfy task, setting its status back usually to `active` or `incomplete`. The exact endpoint depends on the task type: - **Process Task:** `DELETE /organizations/{org_id}/runs/{run_id}/completed-tasks/{task_id}` - **One-off Task:** `DELETE /organizations/{org_id}/completed-tasks/{task_id}` Replace `{org_id}`, `{run_id}` (if applicable), and `{task_id}` with the appropriate IDs. :::note Notice the `DELETE` method is used on the `completed-tasks` endpoint, effectively deleting the "completion" record. ::: ## Request ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Body No request body is needed for this DELETE request. ### Code samples ## Response A successful request returns a `200 OK` status code. The response body typically contains the details of the task, now back in an active (or incomplete) state. ```json { "data": { "id": "TASK_ID_TO_REOPEN", "title": "Review Proposal", "status": "active", // Status is no longer 'completed' "completed_at": null, // Completion timestamp is removed "completer_id": null, // ... other task properties ... } } ``` If the task was not previously completed or the ID is invalid, an error status will be returned. --- - **[Update task](https://tallyfy.com/products/pro/integrations/open-api/code-samples/tasks/update-task/)**: This documentation explains how to update existing Tallyfy tasks using PUT API endpoints with separate URLs for process tasks and one-off tasks and covers modifying properties like title deadline assignees and form field values through taskdata objects with specific formatting requirements for different field types including text dropdowns radio buttons and multi-select checkboxes. ## Endpoint This endpoint updates an existing Tallyfy task. The exact endpoint depends on whether it's a task within a process run or a one-off task: - **Process Task:** `PUT /organizations/{org_id}/runs/{run_id}/tasks/{task_id}` - **One-off Task:** `PUT /organizations/{org_id}/tasks/{task_id}` Replace `{org_id}`, `{run_id}` (if applicable), and `{task_id}` with the appropriate IDs. ## Request ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` - `Content-Type: application/json` ### Body (JSON) The request body requires a JSON object containing the Tallyfy task properties you wish to modify. You only need to include the fields you want to change. Refer to the `#definitions/updateTaskInput` (for process tasks) or `#definitions/updateStandaloneTaskInput` (for one-off tasks) schemas in Swagger for available fields. Common updatable fields include: - `title` (string): New task title. - `summary` / `description` (string): New task description. - `deadline` (string): New deadline in ISO 8601 format (e.g., `YYYY-MM-DDTHH:mm:ssZ`). - `started_at` (string): Set or change the start date/time. - `owners` (object): Update assignees. Structure: `{ "users": [user_id1, ...], "guests": ["guest@email.com", ...], "groups": [group_id1, ...] }`. **This replaces existing assignees.** - `taskdata` (object): Update form field values (see details below). - `status` (string): Change the task status (use with caution, prefer dedicated complete/reopen endpoints where possible). - `webhook` (string): Update the task-specific webhook URL (one-off tasks). - `prevent_guest_comment` (boolean): Enable/disable guest comments. ### Updating form fields using `taskdata` To update form field values, include a `taskdata` object in the request body. The keys within `taskdata` are the **Form Field IDs (Capture IDs)**, and the values depend on the field type: - **Text/Textarea:** `{ "taskdata": { "field_id_abc": "New text value" } }` - **Date:** `{ "taskdata": { "field_id_def": "2025-12-31T23:59:59Z" } }` - **Radio Button:** `{ "taskdata": { "field_id_ghi": "Selected Value Text" } }` - **Dropdown:** `{ "taskdata": { "field_id_jkl": { "id": 3, "text": "Chosen Option Text", "value": null } } }` (Provide the selected option object) - **Multi-select Checkboxes:** `{ "taskdata": { "field_id_mno": [ { "id": 1, ..., "selected": true }, { "id": 2, ..., "selected": false }, { "id": 3, ..., "selected": true } ] } }` (Provide the full array of options with their selected status) - **File/Image:** See [Attach files using the API](https://tallyfy.com/products/pro/integrations/open-api/code-samples/files/upload-attach-file/) sample. Requires pre-uploading. - **Table:** Updating table fields via API might require specific formatting; consult Swagger or Tallyfy support if needed. #### Complete field update example Here's a complete example showing how to update different field types in a single API call: ```json { "taskdata": { "e4238158ad0949d4ad78c55125b28a99": "normal text field", // Short text "ad789434de1c4d5fade2193d237c5716": "Text Area content here", // Long text/textarea "7a54e215a9904096851360917080599f": "yes", // Radio button "8c0161f92eba4d3da7182fed348f3421": "2025-12-20T14:23:18.128Z", // Date field "0e4b280880cc4407a06478a2faa8052b": { // Dropdown selection "id": 2, "text": "Office 365", "value": null }, "fe316c2ac44a421cafbf128c9462b8e9": [ // Multi-select checkboxes { "id": 1, "text": "Slack", "value": null, "required": true, "selected": true }, { "id": 2, "text": "Teams", "value": null, "required": false, "selected": false } ] } } ``` :::tip[Finding Field IDs] If you don't know the Form Field IDs (Capture IDs), you can: 1. Retrieve the task details using the [Get Task](/products/pro/integrations/open-api/code-samples/tasks/get-task/) endpoint with `with=form_fields`. 2. Inspect the network requests in your browser's developer tools when interacting with the task form in the Tallyfy UI. ::: ### Updating assignees using `owners` ```json { "owners": { "users": [1001, 1002], // Assign users 1001 and 1002 "groups": [], // Remove all group assignments "guests": ["new.client@example.com"] // Assign this guest } } ``` :::caution[Assignee Updates Replace] Providing the `owners` object *replaces* all existing assignees with the ones specified in the `users`, `groups`, and `guests` arrays within the object. To remove all assignees, provide empty arrays for all three. ::: ### Code samples ## Response A successful request returns a `200 OK` status code and a JSON object containing the full details of the task *after* the update. ```json { "data": { "id": "TASK_ID_TO_UPDATE", "title": "Go Updated Task Title", // Updated title "summary": "Task summary updated via Python.", // Updated summary "status": "active", "owners": { // Reflects updated assignees "users": [{ "id": 1005, ... }], "groups": [], "guests": [] }, "deadline": "2025-07-01T09:00:00Z", // Updated deadline "last_updated": "2025-05-20T16:00:00Z", // Reflects update time // ... other task properties ... "taskdata": { // Reflects updated form field values "text_field_id_example": "Updated value from JS", "dropdown_field_id_example": { "id": 3, ... }, "radio_button_field_id": "Option B" } } } ``` If the task ID is not found, you lack permission, or the request body is invalid (e.g., incorrect field ID, wrong data type for a field), you will receive an appropriate error status code (`404`, `403`, `400`, `422`). --- ### Members - **[Get member](https://tallyfy.com/products/pro/integrations/open-api/code-samples/members/get-member/)**: This API endpoint retrieves detailed profile information for a specific organization member by their user ID and supports optional query parameters to include related data like statistics and group memberships with code examples provided in JavaScript Python Java Go C++ and C#. ## Endpoint `GET /organizations/{org_id}/users/{user_id}` This endpoint retrieves the profile information for a specific member (user) within your Tallyfy organization, identified by their unique user ID. ## Request Replace `{org_id}` with your Organization ID and `{user_id}` with the numeric ID of the member you want to retrieve. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Query parameters (optional) - `with` (string): Include additional related data. Common options include `stats`, `assets`, `groups` (check Swagger documentation for complete list). ### Code samples ## Response A successful request returns a `200 OK` status code and a JSON object containing a `data` field. The value of `data` is an object representing the requested member's profile. ```json { "data": { "id": 12345, "email": "specific.user@example.com", "username": "specificuser", "first_name": "Specific", "last_name": "User", "full_name": "Specific User", "profile_pic": "https://.../avatar.png", "active": true, "status": "active", "user_role": "Standard", "timezone": "America/Los_Angeles", "created_at": "...", // ... other standard user properties ... // Included if requested with 'with=stats': "stats": { "active_tasks": 15, "completed_tasks": 120, // ... other stats ... }, // Included if requested with 'with=groups': "groups": [ { "id": "group_id_3", "name": "Project Alpha" } ] } } ``` If the user ID is not found or you lack permission, you will receive a `404 Not Found` or `403 Forbidden` error. --- - **[Invite member](https://tallyfy.com/products/pro/integrations/open-api/code-samples/members/invite-member/)**: This API endpoint allows organizations to send email invitations to new users by submitting their email address and optional details like name and role through a POST request which returns the invited user's pending profile information. ## Endpoint `POST /organizations/{org_id}/users/invite` This endpoint sends an invitation email to a new user, prompting them to join your Tallyfy organization. ## Request Replace `{org_id}` with your Organization ID. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` - `Content-Type: application/json` ### Body (JSON) The request body requires a JSON object containing the details of the user to invite. Refer to the `#definitions/inviteInput` schema in Swagger. Key fields: - `email` (string, required): The email address of the person to invite. - `first_name` (string, optional): First name of the invitee. - `last_name` (string, optional): Last name of the invitee. - `role` (string, optional): The role to assign upon joining (e.g., `standard`, `light`, `admin`). Defaults may apply if omitted. - `timezone` (string, optional): Timezone for the new user (e.g., `America/New_York`). **Example Body:** ```json { "email": "new.user@example.com", "first_name": "Charlie", "last_name": "Brown", "role": "standard" } ``` ## Code samples ## Response A successful request returns a `200 OK` or `201 Created` status code. The response body typically contains the details of the invited user, often showing a `pending` or `invited` status until they accept. ```json { "data": { "id": 1005, // User ID assigned even before acceptance "email": "charlie.brown@example.com", "username": null, // Username set upon acceptance "first_name": "Charlie", "last_name": "Brown", "full_name": "Charlie Brown", "profile_pic": null, "active": false, // Not active until accepted "is_suspended": false, "created_at": "2025-01-15T10:00:00Z", "last_updated": "2025-01-15T10:00:00Z", "last_login_at": null, "activated_at": null, // Null until accepted "status": "invited", // Or similar status "user_role": "Standard" // ... other properties ... } } ``` If the email address already belongs to an existing member of the organization, you will likely receive a `422 Unprocessable Entity` error. --- - **[List members](https://tallyfy.com/products/pro/integrations/open-api/code-samples/members/list-members/)**: This endpoint enables retrieval of all registered members within a Tallyfy organization by making a GET request with optional query parameters for including related group data and pagination controls. ## Endpoint `GET /organizations/{org_id}/users` This endpoint retrieves a list of registered members (users) within your Tallyfy organization. ## Request Replace `{org_id}` with your Organization ID. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Query parameters (optional) - `with` (string): Include related data such as `groups`. - Pagination parameters (`page`, `per_page`) may also be available (check Swagger documentation). ### Code samples ## Response A successful request returns a `200 OK` status code and a JSON object containing a `data` array. Each element in the array represents a member user. ```json { "data": [ { "id": 1001, "email": "alice@example.com", "username": "alice", "first_name": "Alice", "last_name": "Smith", "full_name": "Alice Smith", "profile_pic": "https://.../profile.jpg", "active": true, "is_suspended": false, "created_at": "...", "last_updated": "...", "last_login_at": "...", "status": "active", "user_role": "Admin", // Role within the current organization // Included if requested with 'with=groups': "groups": [ { "id": "group_id_1", "name": "Sales Team" }, { "id": "group_id_2", "name": "Support" } ] // ... other user properties ... }, { "id": 1002, "email": "bob@example.com", // ... details for another member ... } ] // Potential meta object for pagination if supported } ``` --- - **[Remove member](https://tallyfy.com/products/pro/integrations/open-api/code-samples/members/remove-member/)**: This endpoint removes a member from a Tallyfy organization using a required two-step process where the user must first be disabled before permanent deletion and optionally allows task reassignment to another member during removal. ## Endpoint `DELETE /organizations/{org_id}/users/{user_id}` This endpoint removes a member from your Tallyfy organization. The user is removed from this specific organization but their global account may remain. Their assigned tasks might become unassigned or require reassignment. ### Two-step deletion process **Important**: Tallyfy uses a two-step deletion process for safety. Members must be **disabled first** before permanent deletion: 1. **Step 1 - Disable**: `DELETE /organizations/{org_id}/users/{user_id}/disable` 2. **Step 2 - Delete**: `DELETE /organizations/{org_id}/users/{user_id}/delete` If you attempt to delete an active member directly, you'll receive an error: `"Please disable the user before deletion"` ## Request Replace `{org_id}` with your Organization ID and `{user_id}` with the numeric ID of the member to remove. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Query parameters (optional) The API provides optional parameters for handling reassignment of the removed member's tasks: - `with_reassignment` (boolean): Set to `true` if you want to reassign tasks. - `to` (integer): If `with_reassignment=true`, provide the User ID of the member to whom tasks should be reassigned. Example: `?with_reassignment=true&to=1002` ### Body No request body is needed for this DELETE request. ### Code samples ## Response A successful request returns a `200 OK` status code and a JSON object containing the removed member's data. ### Common error responses #### 400 Bad Request ```json { "error": "Please disable the user before deletion" } ``` **Solution**: Use the disable endpoint first, then attempt deletion. #### 403 Forbidden ```json { "error": "Cannot modify the default administrator" } ``` **Solution**: Transfer the default administrator role to another user first. ```json { "error": "Cannot disable the last administrator" } ``` **Solution**: Promote another member to administrator role before removal. #### 404 Not Found ```json { "error": "User not found" } ``` **Solution**: Verify the user ID is correct and the member exists in this organization. ### Success response example ```json { "data": { "id": 12345, "email": "john.doe@example.com.deleted.12345", "first_name": "John", "last_name": "Doe (Deleted)", "role": "standard", "status": "deleted", "deleted_at": "2024-01-15T10:30:00Z" } } ``` - **[Update member role](https://tallyfy.com/products/pro/integrations/open-api/code-samples/members/update-member-role/)**: This endpoint allows administrators to modify a member's role within a Tallyfy organization by sending a PUT request with the new role name (such as admin standard or light) and returns the updated user profile upon successful completion. ## Endpoint `PUT /organizations/{org_id}/users/{user_id}/role` This endpoint updates the role of a specific member within your Tallyfy organization. ## Request Replace `{org_id}` with your Organization ID and `{user_id}` with the numeric ID of the member whose role you want to change. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` - `Content-Type: application/json` ### Body (JSON) The request body requires a JSON object specifying the new role. - `role` (string, required): The new role name (such as `admin`, `standard`, `light`). Check your Tallyfy organization settings or documentation for available role names. **Example Body:** ```json { "role": "light" } ``` ## Code samples ## Response A successful request returns a `200 OK` status code and a JSON object containing the member's full profile, reflecting the updated `user_role`. ```json { "data": { "id": 12345, "email": "specific.user@example.com", "first_name": "Specific", "last_name": "User", "user_role": "light", // Role is updated // ... other user properties ... "last_updated": "YYYY-MM-DDTHH:mm:ssZ" // Timestamp reflects the update } } ``` If the user ID or role name is invalid, or you lack permission, an appropriate error status code (`404`, `403`, `400`, `422`) will be returned. --- - **[Update member](https://tallyfy.com/products/pro/integrations/open-api/code-samples/members/update-member/)**: This endpoint enables updating profile information for existing organization members in Tallyfy by sending a PUT request with JSON data containing fields like first name last name phone job title team and timezone while noting that email and password changes require separate dedicated endpoints for security purposes. ## Endpoint `PUT /organizations/{org_id}/users/{user_id}` This endpoint updates the profile information for an existing member (user) within your Tallyfy organization. ## Request Replace `{org_id}` with your Organization ID and `{user_id}` with the numeric ID of the member to update. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` - `Content-Type: application/json` ### Body (JSON) The request body requires a JSON object containing the member profile fields you want to update. Refer to the `#definitions/accountsInput` schema in Swagger for available fields. Common updatable fields include: - `first_name` (string) - `last_name` (string) - `phone` (string) - `job_title` (string) - `job_description` (string) - `team` (string) - `timezone` (string, e.g., `Europe/London`) - `country_id` (integer): ID representing the user's country. - `date_format` (string, e.g., `mm/dd/yyyy`, `dd/mm/yyyy`). **Example Body:** ```json { "first_name": "Alicia", "job_title": "Senior Support Agent", "timezone": "America/New_York" } ``` :::note Updating a member's email or password typically requires separate, dedicated endpoints (such as `/update-email`, `/update-password`) due to security requirements, and may require the user's current password. ::: ### Code samples ## Response A successful request returns a `200 OK` status code and a JSON object containing the full profile of the member *after* the update. ```json { "data": { "id": 12345, "email": "specific.user@example.com", "first_name": "Alicia", // Updated value "last_name": "Smith-Jones", // Updated value "full_name": "Alicia Smith-Jones", "job_title": "Project Lead", // Updated value "phone": "+1-555-123-4567", // Updated value "timezone": "America/New_York", // Updated value // ... other user properties reflecting the current state ... "last_updated": "YYYY-MM-DDTHH:MM:SSZ" // Timestamp reflects the update } } ``` If the user ID is not found, you lack permission, or the request body is invalid, an appropriate error status code (`404`, `403`, `400`, `422`) will be returned. --- ### Templates - **[Create a template](https://tallyfy.com/products/pro/integrations/open-api/code-samples/templates/create-template/)**: This endpoint enables the creation of new Tallyfy templates (blueprints) within an organization by sending a POST request with required title and optional configuration parameters like summary owner webhook settings permissions and kick-off form definitions across multiple programming languages. This endpoint allows you to create a new Tallyfy template (also known as a blueprint) within a specified organization. ## Endpoint ```http POST https://go.tallyfy.com/api/organizations/{org}/checklists ``` ### Path Parameters | Parameter | Type | Description | | :-------- | :------- | :------------------------------------- | | `org` | string | **Required.** The ID of the organization. | ### Body Parameters The request body should be a JSON object containing the desired properties for the new Tallyfy template. | Parameter | Type | Description | | :----------------------------- | :------ | :--------------------------------------------------------------------------------------------------------- | | `title` | string | **Required.** The title of the template. | | `summary` | string | A brief summary or description of the template. | | `owner_id` | integer | The ID of the member who will own the template. | | `webhook` | string | A URL to send webhook notifications to for template events. | | `explanation_video` | string | URL of a video explaining the template. | | `starred` | boolean | Whether the template should be starred by default. | | `guidance` | string | Detailed guidance or instructions for using the template. | | `icon` | string | Name of an icon to associate with the template. | | `is_public` | boolean | Whether the template should be publicly accessible in the library. | | `is_featured` | boolean | Whether the template should be featured in the public library. | | `public_cover` | string | URL for a cover image for the public library listing. | | `type` | string | The type of template (e.g., `procedure`, `form`, `document`). | | `default_process_name_format` | string | A format string for automatically naming processes launched from this template (uses variables). | | `is_public_kickoff` | boolean | Whether the kick-off form for this template is public. | | `auto_naming` | boolean | Enable or disable automatic naming of processes launched from this template based on the format string. | | `users` | array | An array of member IDs who have default access permissions to this template. | | `groups` | array | An array of group IDs that have default access permissions to this template. | | `prerun` | array | An array of objects defining kick-off form fields for the template. See `swagger.json` for structure. | | `folderize_process` | boolean | Automatically create a folder for processes launched from this template. | | `tag_process` | boolean | Automatically tag processes launched from this template. | | `allow_launcher_change_name` | boolean | Whether the user launching a process can override the default process name. | | `ko_form_blueprint_id` | string | ID of another template to use as the kick-off form. | | `default_folder` | string | The ID of the folder where processes launched from this template should be placed by default. | | `folder_changeable_by_launcher`| boolean | Whether the user launching a process can change the default folder. | | `kickoff_sharing_user_id` | integer | The ID of the user whose sharing settings should be used for the public kick-off form. | ## Code Samples ## Example Response (200 OK) ```json { "data": { "id": "b3d9c1a8e7f6...", // Unique ID of the newly created template "title": "New Client Onboarding Template", "summary": "Standard procedure for onboarding new clients.", "starred": false, "webhook": null, "explanation_video": null, "guidance": null, "icon": null, "alias": "new-client-onboarding-template-b3d9c1", // Auto-generated alias "prerun": [], // Empty array as no kick-off fields were defined "automated_actions": [], "created_by": 123, // ID of the user who made the API call "owner_id": 12345, "started_processes": 0, "kickoff_title": null, "kickoff_description": null, "created_at": "2025-10-27T10:00:00.000Z", "last_updated": "2025-10-27T10:00:00.000Z", "archived_at": null, "is_public": false, "is_featured": false, "users": [], "groups": [], "public_cover": null, "industry_tags": [], "topic_tags": [], "type": "procedure", "default_process_name_format": null, "is_public_kickoff": false, "dual_version_enabled": false, "is_published_state": false, // Templates are created in draft state "auto_naming": false, "last_updated_by": 123, "linked_tasks": [], "folderize_process": false, "tag_process": false, "allow_launcher_change_name": false, "is_pinned": false, "ko_form_blueprint_id": null, "default_folder": null, "folder_changeable_by_launcher": false, "kickoff_sharing_user_id": null // ... other template properties with default values } } ``` - **[Archive or delete template](https://tallyfy.com/products/pro/integrations/open-api/code-samples/templates/delete-archive-template/)**: Templates can be removed via API through either archiving (soft delete that hides the template while preserving data and allowing restoration) or permanent deletion (irreversible removal of all template data) using DELETE requests to different endpoints with appropriate authentication headers. There are two ways to remove a template via the API: 1. **Archive (Soft Delete):** Hides the template from the library but retains its data. Processes already launched from it continue to run. Archived templates can be restored. 2. **Delete (Permanent):** Permanently removes the template and its associated data. This action cannot be undone. ### 1. Archive Template #### Endpoint `DELETE /organizations/{org_id}/checklists/{checklist_id}` This endpoint archives the specified template. #### Request Replace `{org_id}` with your Organization ID and `{checklist_id}` with the ID of the template to archive. ##### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ##### Body No request body is needed for this DELETE request. #### Code samples for archiving #### Response examples for archiving A successful archive request typically returns a `200 OK` status code. The response body *may* contain the details of the archived template, now including an `archived_at` timestamp. ```json { "data": { "id": "TEMPLATE_ID_TO_ARCHIVE", "title": "Template To Be Archived", // ... other properties ... "archived_at": "2025-05-20T13:00:00.000Z" // Timestamp indicates archival } } ``` ### 2. Permanently delete Template :::danger[Irreversible Action] Permanently deleting a template cannot be undone. All associated template data will be lost. Consider archiving unless you are absolutely sure. ::: #### Endpoint `DELETE /organizations/{org_id}/checklists/{checklist_id}/delete` Note the extra `/delete` path segment compared to the archive endpoint. #### Request Replace `{org_id}` and `{checklist_id}` as appropriate. ##### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ##### Body No request body is needed. #### Code samples for archiving and deleting #### Response examples for archiving A successful archive request typically returns a `200 OK` status code. The response body *may* contain the details of the archived template, now including an `archived_at` timestamp. ```json { "data": { "id": "TEMPLATE_ID_TO_ARCHIVE", "title": "Template To Be Archived", // ... other properties ... "archived_at": "2025-05-20T13:00:00.000Z" // Timestamp indicates archival } } ``` #### Response examples for permanent deletion A successful permanent deletion typically returns a `200 OK` or `204 No Content` status code. The response body, if present for a `200 OK`, might contain a success message. - **[Get template](https://tallyfy.com/products/pro/integrations/open-api/code-samples/templates/get-template/)**: This endpoint retrieves complete details for a specific process template by its unique ID and supports optional query parameters to include related data like steps tags and form fields in the response. ## Endpoint `GET /organizations/{org_id}/checklists/{checklist_id}` This endpoint retrieves the full details for a single process template (blueprint) identified by its unique ID. ## Request Replace `{org_id}` with your Organization ID and `{checklist_id}` with the specific ID of the template you want to retrieve. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Query parameters (optional) - `with` (string): A comma-separated list of related data to include (e.g., `steps`, `runs`, `folder`, `threads`, `tags`, `assets`, `starredByUsers`). Example: `with=steps,tags` - `version` (integer): Retrieve a specific version of the template. - `type` (string): Filter by type (e.g., `procedure`, `form`). - `entire_folder_tree` (string, `"0"` or `"1"`): Include the template's full folder hierarchy. ### Code samples ## Response A successful request returns a `200 OK` status code and a JSON object containing a `data` field. The value of `data` is an object representing the requested template with its full details. ```json { "data": { "id": "YOUR_TEMPLATE_ID", "title": "Customer Onboarding Process", "summary": "Standard process for onboarding new customers.", "starred": false, "webhook": null, "explanation_video": null, "guidance": "Detailed guidance notes here.", "icon": "fa-users", "alias": "customer-onboarding-v2", "prerun": [ // Kick-off form fields { "id": "prerun_field_1", "checklist_id": "YOUR_TEMPLATE_ID", "alias": "customer_name", "field_type": "text", // ... other prerun field properties ... } ], "automated_actions": [], // Rules "created_by": 1001, "owner_id": 1001, "created_at": "2025-01-10T10:00:00.000Z", "last_updated": "2025-05-15T14:30:00.00Z", "archived_at": null, "is_public": false, // ... many other template properties ... // Included if requested via 'with' parameter: "steps": [ { "id": "step_1_id", "checklist_id": "YOUR_TEMPLATE_ID", "alias": "welcome_call", "title": "Schedule Welcome Call", // ... other step properties ... } // ... more steps ... ], "tags": [ { "id": "tag_abc", "title": "Onboarding", "color": "#3498db" } ] } } ``` If the template ID is not found or you don't have permission, you will likely receive a `404 Not Found` or `403 Forbidden` error. --- - **[Update template](https://tallyfy.com/products/pro/integrations/open-api/code-samples/templates/update-template/)**: This endpoint enables updating existing process template properties by sending a PUT request with only the fields you want to modify such as title summary owner guidance or starred status while noting that updating user or group arrays will replace the entire existing list rather than adding to it. ## Endpoint `PUT /organizations/{org_id}/checklists/{checklist_id}` This endpoint allows you to update the properties of an existing process template (blueprint) identified by its ID. ## Request Replace `{org_id}` with your Organization ID and `{checklist_id}` with the ID of the template you want to update. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` - `Content-Type: application/json` ### Body (JSON) The request body requires a JSON object containing the template properties you wish to modify. You only need to include the fields you want to change. Refer to the `#definitions/createChecklistInput` schema in the Swagger specification for the full list of updatable properties (it's often the same or similar to the creation schema). Common fields to update include: - `title` (string) - `summary` (string) - `owner_id` (integer) - `webhook` (string) - `guidance` (string) - `starred` (boolean) - `type` (string) - `users` (array of integers) - Note: This usually *replaces* the existing list. - `groups` (array of strings) - Note: This usually *replaces* the existing list. **Example Body (Updating title and summary):** ```json { "title": "Updated Template Name", "summary": "This template has been updated via the API." } ``` :::caution[Updating Arrays (Users/Groups)] When updating fields like `users` or `groups`, the provided array typically *replaces* the entire existing list of users or groups associated with the template permission, rather than adding to it. Ensure you provide the complete intended list if you modify these. ::: ### Code samples ## Response A successful request returns a `200 OK` status code and a JSON object containing the full details of the template *after* the update. ```json { "data": { "id": "TEMPLATE_ID_TO_UPDATE", "title": "Updated via JS Fetch", // Updated title "summary": "This template has been updated via the API.", // Original or updated summary "starred": true, // Updated value // ... other template properties reflecting the current state ... "last_updated": "2025-05-20T12:30:00.000Z" // Timestamp reflects the update } } ``` If the template ID is not found, you lack permission, or the request body is invalid, you will receive an appropriate error status code (`404`, `403`, `400`, `422`). --- - **[List templates](https://tallyfy.com/products/pro/integrations/open-api/code-samples/templates/list-templates/)**: This API endpoint retrieves available process templates (called Blueprints or Checklists in the API) from an organization using a GET request with optional query parameters for filtering pagination and search functionality. ## List Templates API Endpoint This endpoint retrieves a list of process templates (known as "Checklists" or "Blueprints" in the API) available within the specified organization. :::note[API vs UI Terminology] Note that while in the Tallyfy user interface these are called **Templates**, the API consistently refers to them as **Blueprints** or sometimes **Checklists**. ::: ## Endpoint `GET /organizations/{org_id}/checklists` ## Request Replace `{org_id}` with your actual Organization ID. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Query parameters (optional) Refer to the `GET /organizations/{org}/checklists` endpoint in the Swagger specification or API reference for optional query parameters like `with`, `type`, `q` (search), `page`, `per_page`, etc., to filter or paginate results. ### Code samples ## Response A successful request returns a `200 OK` status code and a JSON object containing a `data` array. Each element in the `data` array represents a template with its details. ```json { "data": [ { "id": "c15bf2be31c3a7fbded5d13fce7aaab9", "title": "Customer Onboarding Process", "summary": "Standard process for onboarding new customers.", "starred": false, // ... other template properties ... "created_at": "2025-01-10T10:00:00.000Z", "last_updated": "2025-05-15T14:30:00.000Z" }, { "id": "a987654321abcdefa987654321abcdef", "title": "Employee Offboarding Checklist", "summary": "Steps to take when an employee leaves.", // ... other template properties ... } // ... more templates ... ], "meta": { "pagination": { "total": 25, "count": 10, "per_page": 10, "current_page": 1, "total_pages": 3, "links": { "next": "https://go.tallyfy.com/api/organizations/{org_id}/checklists?page=2" } } } } ``` If pagination is used, the `meta` object provides details about the total number of templates, current page, etc., and links to navigate through pages. --- ### Byo ai - **[ChatGPT integration](https://tallyfy.com/products/pro/integrations/byo-ai/chatgpt-integration/)**: ChatGPT Plus and Pro subscribers can connect to Tallyfy through MCP protocol and OAuth 2.1 authentication to search manage and automate workflow tasks processes and templates using natural language commands directly in their chat interface. :::note[Beta Integration Status] MCP (Model Context Protocol) integration with ChatGPT is currently in **BETA**. Available only to ChatGPT Plus and ChatGPT Pro subscribers through Developer Mode. OAuth 2.1 endpoints are live at `mcp.tallyfy.com`. ::: ## Connecting ChatGPT to automate Tallyfy tasks Your ChatGPT Plus or Pro subscription can become a workflow automation engine for Tallyfy. Through MCP (Model Context Protocol) and OAuth 2.1 authentication, ChatGPT connects to your Tallyfy workspace to search, read, and manage tasks, processes, and templates using natural language - all through the subscription you already pay for. ### How ChatGPT integration works The integration uses OpenAI's Connectors platform with MCP (Model Context Protocol) to create a secure bridge between ChatGPT and your Tallyfy workspace: 1. **MCP server connection**: ChatGPT connects to Tallyfy's MCP server at `mcp.tallyfy.com` 2. **OAuth 2.1 authentication**: You authorize ChatGPT to access your Tallyfy workspace through a secure OAuth flow 3. **Natural language queries**: Ask ChatGPT to search tasks, check process status, or retrieve template information 4. **Tool execution**: ChatGPT uses MCP tools to read and write data in your Tallyfy workspace 5. **Intelligent responses**: ChatGPT processes your requests and returns structured information or confirms actions No API keys to manage. No code to write. Just enable Developer Mode, connect the MCP server, and start automating. ### Setting up the connection **Prerequisites**: - ChatGPT Plus or ChatGPT Pro subscription - Active Tallyfy account with at least Standard user role - Developer Mode enabled in ChatGPT settings **Step-by-step setup**: 1. **Enable Developer Mode** in ChatGPT: - Click your profile icon (top left) - Select **Settings** → **Apps and Connectors** - Scroll to **Advanced Settings** - Enable **Developer Mode** (beta feature) 2. **Create a new Connector**: - In ChatGPT, go to **Settings** → **Connectors** - Click **Create** - **Connector name**: Tallyfy - **Description**: "Connect to Tallyfy to search and manage workflow tasks, processes, and templates" 3. **Configure the MCP server**: - **MCP Server URL**: `https://mcp.tallyfy.com` - **Authentication**: OAuth 2.1 with PKCE - ChatGPT will automatically discover authentication endpoints 4. **Authorize the connection**: - Click **Connect** and you'll be redirected to Tallyfy's login page - Log in with your Tallyfy credentials - Review and approve the permissions request (you'll see which scopes are requested) - ChatGPT stores refresh tokens for persistent access - You can revoke access anytime from ChatGPT Settings → Connectors ### OAuth endpoints (automatically discovered) **MCP Server**: `https://mcp.tallyfy.com` **Authorization endpoint**: `https://go.tallyfy.com/mcp/oauth/authorize` **Token endpoint**: `https://go.tallyfy.com/mcp/oauth/token` **OAuth Metadata**: `https://go.tallyfy.com/.well-known/oauth-authorization-server` **Supported OAuth scopes** (granular read/write permissions): - `mcp.users.read` - View user and guest information - `mcp.users.write` - Modify user permissions and settings - `mcp.tasks.read` - Search and retrieve task data - `mcp.tasks.write` - Create, update, and complete tasks - `mcp.processes.read` - View workflow process status - `mcp.processes.write` - Manage process lifecycle - `mcp.templates.read` - Access template configurations - `mcp.templates.write` - Modify templates and steps - `mcp.forms.read` - View form field definitions - `mcp.forms.write` - Update form fields and options - `mcp.automation.read` - View automation rules - `mcp.automation.write` - Create and modify automation rules ### Available MCP tools Once connected, ChatGPT can use these Tallyfy MCP tools through natural language: #### Search capabilities - **Search for tasks**: Find tasks across your organization by keywords or criteria - **Search for processes**: Locate running workflow processes (runs) - **Search for templates**: Discover workflow templates (blueprints) #### Task management - **Get my tasks**: Retrieve all tasks assigned to you - **Get user tasks**: View tasks assigned to any user - **Get tasks for process**: List all tasks in a specific workflow process - **Create task from text**: Generate a new task using natural language description #### Process management - **Get organization runs**: View all active workflow processes in your organization #### Template management - **Get template**: Retrieve complete template configuration - **Get all templates**: List all available workflow templates - **Get step dependencies**: View task dependencies within templates - **Get kickoff fields**: Access template launch form fields - **Update kickoff field**: Modify launch form field properties - **Delete kickoff field**: Remove fields from launch forms #### Form fields - **Update form field**: Modify task form field properties - **Delete form field**: Remove form fields from tasks - **Get dropdown options**: Retrieve choices for dropdown fields - **Update dropdown options**: Modify dropdown field choices #### Automation rules - **Create automation rule**: Add if-this-then-that logic to templates - **Update automation rule**: Modify existing automation rules - **Delete automation rule**: Remove automation rules - **Get step visibility conditions**: View conditional display rules #### User and group management - **Get organization users**: List all users in your workspace - **Get organization guests**: View external guest users - **Get organization guests list**: Simplified guest user listing ### Write operation security ChatGPT displays **explicit confirmation modals** before executing any write or modify operations (create, update, delete). This prevents accidental changes and gives you full control over what the AI can modify in your Tallyfy workspace. ### Real-world usage examples **Finding urgent tasks** ``` You: "Show me all urgent tasks assigned to the sales team" ChatGPT: Uses search_for_tasks tool → Returns filtered task list with details ``` **Checking process status** ``` You: "What's the status of the employee onboarding process for John Smith?" ChatGPT: Uses search_for_processes tool → Returns process details, completion percentage, current step ``` **Template discovery** ``` You: "Find all templates related to customer support workflows" ChatGPT: Uses search_for_templates tool → Lists matching templates with descriptions ``` **Bulk task review** ``` You: "Get all my tasks and summarize which ones are overdue" ChatGPT: Uses get_my_tasks tool → Analyzes due dates and provides organized summary ``` **Creating automation rules** ``` You: "Add a rule to the Sales Template that sends an email notification when the 'contract_value' field exceeds $50,000" ChatGPT: Uses create_automation_rule tool → Confirms creation after your approval ``` **Template configuration** ``` You: "Show me all the form fields in the Customer Onboarding template" ChatGPT: Uses get_template tool → Lists all form fields with their types and properties ``` ### Best practices for natural language queries **Be specific with search terms** ``` Good: "Find all tasks with 'invoice approval' in the title assigned to me" Bad: "Show tasks" ``` **Provide context for filtering** ``` Good: "Get processes created in the last 7 days with 'onboarding' in the name" Bad: "Find recent processes" ``` **Specify exactly what you want to modify** ``` Good: "Update the 'Priority' dropdown field in the Bug Report template to include 'Critical' as an option" Bad: "Change the priority field" ``` **Ask for structured summaries** ``` Good: "List all my tasks grouped by due date, show only title and assignee" Bad: "What are my tasks?" ``` ### Security and data handling **Built-in safeguards**: - **OAuth 2.1 authentication**: Secure token-based access with PKCE (Proof Key for Code Exchange) - **Granular scoped permissions**: 12 separate read/write scopes for users, tasks, processes, templates, forms, and automations - **Write confirmations**: ChatGPT displays explicit modals before any create, update, or delete operations - **Token management**: Refresh tokens stored securely by OpenAI, revocable from ChatGPT settings - **Audit logging**: All MCP tool executions are logged in Tallyfy for compliance tracking - **No training on your data**: OpenAI doesn't use API interactions for model training (per OpenAI Enterprise Agreement) **Important security notes**: - Only connect MCP servers you trust - prompt injection attacks are possible - Review all write operations before confirming them in ChatGPT - Regularly audit which Connectors have access to your Tallyfy workspace - Revoke access immediately if you suspect unauthorized use ### Rate limits and performance **OpenAI limits apply**: - ChatGPT Plus: Standard message limits per 3-hour window - ChatGPT Pro: Higher limits with priority access **Tallyfy API limits**: - All MCP tool calls count toward your Tallyfy API rate limits - Standard rate limiting applies per organization **Performance tips**: - Be specific in queries to reduce unnecessary tool calls - Use search tools to filter before requesting full details - Batch related questions in a single conversation - ChatGPT caches tool results within the same conversation ### Troubleshooting common issues **"ChatGPT says it can't find the Tallyfy connector"** - Verify Developer Mode is enabled in ChatGPT settings - Check that you have ChatGPT Plus or Pro subscription (not Team/Enterprise yet) - Re-create the Connector with the correct MCP server URL: `https://mcp.tallyfy.com` **"Authentication failed or keeps expiring"** - Re-authorize the OAuth connection in ChatGPT Settings → Connectors - Check if your ChatGPT and Tallyfy subscriptions are both active - Verify you have at least Standard user role in Tallyfy - Clear browser cache and try reconnecting **"ChatGPT says it can't access certain tools"** - Verify the OAuth scopes were approved during connection - Check that your Tallyfy user role has permissions for that operation - Some write operations require Administrator role **"Search results are empty or incomplete"** - Make search queries more specific - Check that the items you're searching for actually exist in your workspace - Verify your Tallyfy user account has permission to view those items ### Advanced usage patterns **Cross-referencing multiple data sources** ``` You: "Find the employee onboarding template, get all its form fields, then show me all active onboarding processes and highlight which fields are most commonly left empty" ChatGPT: 1. Uses get_all_templates to find onboarding template 2. Uses get_template to retrieve form field details 3. Uses search_for_processes to find active onboarding processes 4. Analyzes and summarizes field completion patterns ``` **Bulk analysis and reporting** ``` You: "Get all tasks assigned to the sales team, categorize them by type, and create a summary showing workload distribution" ChatGPT: 1. Uses search_for_tasks with sales team filter 2. Analyzes task titles and descriptions 3. Groups by category 4. Generates distribution report ``` **Template optimization insights** ``` You: "Compare the Customer Support and Bug Triage templates, identify common steps, and suggest opportunities for consolidation" ChatGPT: 1. Uses get_template for both templates 2. Extracts and compares step configurations 3. Identifies duplicated logic 4. Suggests optimization opportunities ``` ### Getting started checklist 1. **Verify subscription**: Ensure you have ChatGPT Plus or ChatGPT Pro (Team/Enterprise not yet supported) 2. **Enable Developer Mode**: ChatGPT Settings → Apps and Connectors → Advanced Settings → Enable Developer Mode 3. **Create Connector**: Settings → Connectors → Create → Name: "Tallyfy" 4. **Add MCP server URL**: `https://mcp.tallyfy.com` 5. **Authorize OAuth connection**: Log in to Tallyfy and approve permissions 6. **Test with simple query**: "Show me my tasks" or "List all templates" 7. **Try advanced queries**: Search, filter, and analyze your workflow data 8. **Monitor usage**: Review which tools are most helpful for your workflow **For developers**: OpenAI's MCP documentation at `platform.openai.com/docs/mcp` provides technical details on building custom MCP servers. The Apps SDK (`developers.openai.com/apps-sdk`) enables building custom UIs for enhanced user experiences. ### Cost considerations **ChatGPT subscription costs**: - ChatGPT Plus: $20/month per user - ChatGPT Pro: $200/month per user (higher rate limits, priority access) - MCP integration included - no additional AI costs **Tallyfy API usage**: - All MCP tool calls count toward your Tallyfy API rate limits - Standard API limits apply per organization - No per-call charges for MCP tools **Optimization tips**: - Use specific queries to minimize unnecessary tool calls - Leverage ChatGPT's conversation memory to avoid re-fetching data - ChatGPT Pro provides better performance for heavy MCP usage Your ChatGPT subscription becomes a workflow intelligence layer - search, analyze, and automate Tallyfy operations using natural language instead of navigating multiple screens. - **[Claude integration](https://tallyfy.com/products/pro/integrations/byo-ai/claude-integration/)**: Tallyfy integrates with Claude through MCP servers and OAuth2 authentication to enable sophisticated AI-powered workflow automation including complex document analysis and multi-step reasoning and high-quality content generation that leverages Claude's analytical capabilities directly within your existing subscription. :::note[Integration Status] This integration is live and operational. OAuth 2.1 endpoints are active, and Claude supports both local MCP servers and remote MCP servers with Streamable HTTP transport. SSE transport is deprecated - use Streamable HTTP for new integrations. ::: ## Connecting Claude for intelligent workflow automation Your Claude Pro or Team subscription brings advanced reasoning and analytical capabilities directly into Tallyfy workflows. Through Model Context Protocol (MCP) servers and OAuth2, Claude reads your task context, applies sophisticated analysis, and completes complex work that requires nuanced understanding - using the Claude subscription you already have. ### How Claude integration works Claude integration leverages Anthropic's MCP (Model Context Protocol) framework for secure, intelligent connections: 1. **MCP server setup**: Tallyfy hosts MCP servers that Claude can connect to 2. **OAuth2 authentication**: Secure authorization links your Claude account 3. **Context window optimization**: Smart chunking sends relevant task data 4. **Advanced reasoning**: Claude processes with its full analytical capabilities 5. **Structured responses**: Results flow back in formats Tallyfy understands Claude excels at tasks requiring deep analysis, careful reasoning, and nuanced judgment - perfect for complex workflow decisions. ### Authentication architecture Claude uses enterprise-grade OAuth 2.1 with MCP extensions. All endpoints are live and operational: **MCP server**: `https://mcp.tallyfy.com` **Authorization endpoint**: `https://go.tallyfy.com/mcp/oauth/authorize` **Token endpoint**: `https://go.tallyfy.com/mcp/oauth/token` **DCR endpoint**: `https://go.tallyfy.com/mcp/oauth/register` **OAuth Metadata**: `https://go.tallyfy.com/.well-known/oauth-authorization-server` **Scopes supported**: `mcp:tasks`, `mcp:processes`, `mcp:templates`, `mcp:users`, `mcp:read`, `mcp:write` **Connection options**: - **Remote MCP servers**: Direct URL-based connection with OAuth 2.1 - no local setup required, hosted on Cloudflare - **Local MCP servers**: Standard input/output (stdio) for local development - **Transport**: Use Streamable HTTP (SSE is deprecated and being phased out) The MCP protocol adds: - Tool discovery for available Tallyfy actions - Schema validation for data integrity - Secure sandboxing of operations - Audit trails for every interaction - Desktop Extensions (.mcpb) for one-click installation ### Task automation with Claude's strengths #### Complex document analysis Claude excels at understanding lengthy, complex documents: - Legal contract review with clause-by-clause analysis - Technical documentation review for accuracy and completeness - Research synthesis from multiple sources - Compliance audit against detailed requirements #### Multi-step reasoning Claude handles tasks requiring careful thought: ``` Task: Evaluate Project Proposal Claude instruction: "Review the attached proposal against our evaluation criteria. Score each section (feasibility, budget, timeline, risk). Identify any gaps or concerns. Provide a detailed recommendation with specific conditions for approval." ``` #### Writing and documentation Claude generates high-quality written content: ``` Task: Create Process Documentation Claude instruction: "Based on the process steps completed so far, write detailed documentation including: purpose, prerequisites, step-by-step steps, common issues, and best practices. Format in our standard template structure." ``` #### Data analysis with context Claude understands nuanced data patterns: ``` Task: Analyze Customer Feedback Claude instruction: "Review all feedback from this quarter. Identify recurring themes, sentiment patterns, and emerging issues. Correlate with product changes. Generate actionable insights for each department." ``` ### Real-world automation examples **RFP response generation** ``` Workflow: RFP Response Process Claude's role: Reads RFP requirements, matches against your capabilities database, generates tailored responses for each section, flags areas needing human input, maintains consistent tone and messaging. ``` **Employee performance reviews** ``` Workflow: Quarterly Review Process Claude's role: Synthesizes feedback from multiple sources, identifies patterns and growth areas, drafts balanced review narrative, suggests specific development goals, ensures consistency across reviews. ``` **Incident analysis and reporting** ``` Workflow: Incident Management Claude's role: Analyzes incident details, determines root cause, assesses impact and severity, generates detailed report with timeline, recommends preventive measures. ``` ### Claude-specific instruction patterns **Leverage Claude's analytical depth** ``` Good: "Analyze the proposal considering technical feasibility, financial viability, strategic alignment, and risk factors. Provide weighted scoring for each dimension with detailed justification." Bad: "Review the proposal and approve or reject." ``` **Use Claude's context window effectively** ``` Good: "Using all previous task responses in this process, identify patterns and generate a complete summary highlighting key decisions and their rationales." Bad: "Summarize this process." ``` **Enable structured reasoning** ``` Good: "First, identify all stakeholders affected. Second, analyze impact on each group. Third, recommend mitigation strategies. Finally, provide an implementation timeline." Bad: "Figure out who this affects and what to do." ``` ### MCP server capabilities The Tallyfy MCP server exposes these tools to Claude: **Task operations** - `get_task`: Retrieve full task context - `complete_task`: Mark task complete with data - `add_comment`: Add analytical comments - `update_fields`: Fill form fields with generated content **Process operations** - `get_process_history`: Access complete process context - `trigger_automation`: Initiate conditional branches - `create_subtask`: Generate follow-up tasks **File operations** - `read_attachment`: Extract and analyze file contents - `generate_document`: Create formatted documents - `update_template`: Suggest process improvements ### Advanced Claude features **Constitutional AI alignment** Claude follows ethical guidelines automatically: - Refuses inappropriate requests - Maintains data privacy - Provides balanced analysis - Explains reasoning transparently **Long context handling** Claude handles up to 200K tokens (1M in beta for Sonnet 4.5): - Entire process histories - Multiple document attachments - Full analysis across steps - Pattern recognition over time **Multilingual capabilities** Claude processes multiple languages: - Automatic language detection - Translation with context preservation - Cultural nuance awareness - Localized content generation ### Performance optimization **Context management strategies**: - Send only relevant historical data - Summarize previous steps when possible - Use references instead of full documents - Implement progressive disclosure **Token optimization**: ``` Efficient: "Analyze Section 3.2 of the contract for liability terms" Wasteful: "Read the entire contract and find liability information" ``` **Response formatting**: ``` Structured: "Return as JSON: {approved: boolean, reason: string, conditions: array}" Unstructured: "Tell me your thoughts on this" ``` ### Security and compliance Claude integration maintains enterprise security: - **No training on your data**: Anthropic doesn't train on API inputs - **Data isolation**: Each organization's data remains separate - **Audit logging**: Complete interaction history - **GDPR compliant**: Data deletion on request - **SOC 2 Type II**: Anthropic maintains compliance ### Troubleshooting **"Claude times out on complex tasks"** - Break into smaller subtasks - Reduce context window size - Implement checkpoints for long analyses **"Responses lack specific details"** - Provide more context in instructions - Include examples of desired output - Reference specific data fields **"MCP connection fails"** - Verify OAuth tokens are current - Check MCP server endpoint availability - Review permission scopes - Try re-authorizing if OAuth was set up before December 2025 (known issues with older tokens) **"SSE connection errors"** - SSE transport is deprecated - migrate to Streamable HTTP - Update your MCP configuration to use Streamable HTTP transport - Remote MCP servers on Cloudflare only support Streamable HTTP **"Desktop Extension not installing"** - Ensure you have the latest Claude Desktop version - Desktop Extensions require macOS or Windows - Check system requirements for .mcpb file support ### Implementation best practices 1. **Start with high-value tasks**: Focus on complex decisions requiring analysis 2. **Provide clear context**: Claude performs best with complete information 3. **Use structured formats**: Define expected output schemas 4. **Implement review steps**: Add human checkpoints for critical decisions 5. **Monitor and iterate**: Review Claude's outputs to refine instructions ### Cost considerations Using your Claude subscription efficiently: - Claude Pro: $20/month for individual use - Claude Team: $25/user/month with higher limits - No additional Tallyfy charges for BYO AI - API calls count toward your Anthropic quotas ### Available Claude models Tallyfy works with all current Claude models through your subscription: - **Claude Opus 4.5**: Anthropic's flagship model with the strongest reasoning, coding, and agentic capabilities. Ideal for complex multi-step analysis and long-horizon tasks. - **Claude Sonnet 4.5**: Best balance of speed and capability. State-of-the-art coding performance with 1M token context window (beta). - **Claude Sonnet 4**: Fast hybrid model with extended thinking for deeper reasoning when needed. - **Claude Haiku 4.5**: Fastest and most cost-efficient option, matching Sonnet 4 performance on many tasks. All models support text and image input, multilingual capabilities, and vision for document analysis. Claude brings sophisticated analysis to every workflow. Complex decisions that took hours of human review now happen automatically, with reasoning you can trust and audit. - **[Microsoft Copilot integration](https://tallyfy.com/products/pro/integrations/byo-ai/microsoft-copilot-integration/)**: Microsoft 365 Copilot integration with Tallyfy leverages API plugins and Azure AD authentication to connect your organization's emails documents and Teams conversations directly into workflow automation while maintaining enterprise security policies and enabling intelligent features like email-driven process creation document analysis and context-aware task routing through declarative agents and Graph API access. ## Integrating Microsoft 365 Copilot with Tallyfy workflows Your Microsoft 365 Copilot subscription becomes a workflow automation powerhouse when connected to Tallyfy. Through API plugins and enterprise OAuth2, Copilot brings the full context of your Microsoft ecosystem - emails, documents, Teams conversations, SharePoint data - directly into workflow automation while maintaining your organization's security policies. ### How Microsoft Copilot integration works Copilot integration uses Microsoft's API plugin framework with enterprise authentication: 1. **API plugin deployment**: Install the Tallyfy plugin in your Microsoft 365 admin center 2. **Azure AD authentication**: Single sign-on through your existing Microsoft identity 3. **Graph API access**: Copilot accesses your Microsoft 365 data with permissions 4. **Declarative agents**: Configure Copilot agents for specific workflow scenarios 5. **Compliance maintained**: All actions respect your organization's policies Unlike standalone AI, Copilot knows your organization's context - who works on what, document history, communication patterns - making it uniquely powerful for enterprise workflows. ### Authentication and security Microsoft Copilot uses enterprise-grade Azure AD OAuth2: **Authorization endpoint**: `https://login.microsoftonline.com/{tenant}/oauth2/v2.0/authorize` **Token endpoint**: `https://login.microsoftonline.com/{tenant}/oauth2/v2.0/token` **Required permissions**: - `Tasks.ReadWrite` - `Workflows.ReadWrite` - `Files.Read` - `User.Read` Enterprise features: - Conditional access policies apply - Multi-factor authentication enforced - Sensitivity labels respected - Data loss prevention active - Compliance boundaries maintained ### Using Microsoft 365 context #### Email-driven automation Copilot reads Outlook emails to trigger workflows: ``` Scenario: Contract Request Email Copilot action: Detects contract request email, extracts requirements, creates Tallyfy process with pre-filled data, assigns to legal team, attaches relevant email thread. ``` #### Document intelligence Copilot analyzes SharePoint and OneDrive files: ``` Scenario: Policy Update Process Copilot action: Compares new policy version with previous, identifies all changes, determines affected departments, generates summary for approval, creates review tasks for stakeholders. ``` #### Teams collaboration Copilot bridges Teams and Tallyfy: ``` Scenario: Project Kickoff Copilot action: Reads Teams meeting transcript, extracts action items, creates Tallyfy process with tasks assigned based on discussion, sets deadlines from mentioned dates, links to Teams channel. ``` ### Real-world enterprise examples **Employee onboarding automation** ``` Workflow: New Hire Process Copilot role: Reads offer letter from email, creates AD account through Graph API, assigns Microsoft 365 licenses, generates equipment request, schedules Teams meetings with manager, creates training task list based on role. ``` **Compliance review process** ``` Workflow: Quarterly Compliance Check Copilot role: Scans all SharePoint documents for compliance markers, identifies documents needing review, checks against regulatory changes, generates audit report, assigns review tasks to document owners. ``` **Customer proposal generation** ``` Workflow: RFP Response Copilot role: Searches previous proposals in SharePoint, finds relevant sections, adapts content to new requirements, maintains brand consistency, pulls latest pricing from Excel, assembles complete proposal. ``` ### Declarative agent configuration Create specialized Copilot agents for your workflows: **Sales Process Agent** ```yaml name: Sales Workflow Assistant instructions: | Monitor sales emails for new opportunities. Create opportunity processes in Tallyfy. Pull customer data from Dynamics 365. Generate proposals using SharePoint templates. Schedule follow-ups based on email sentiment. knowledge: - SharePoint: /sites/Sales/Templates - Teams: Sales Team Channel - CRM: Dynamics 365 Sales actions: - Create Tallyfy process - Assign tasks by territory - Generate documents - Schedule meetings ``` **HR Operations Agent** ```yaml name: HR Process Manager instructions: | Process employee requests from Forms. Check policy documents for guidance. Route approvals based on org chart. Update HR systems automatically. Maintain compliance audit trail. knowledge: - SharePoint: /sites/HR/Policies - Teams: HR Support Channel - HRIS: Workday connection actions: - Create employee processes - Route hierarchical approvals - Update employee records - Generate HR documents ``` ### Microsoft Graph API integration Copilot accesses your organization's data through Graph API: **Available data sources**: - User profiles and organizational hierarchy - Calendar availability and meeting details - Email content and attachments - SharePoint documents and lists - Teams messages and files - OneDrive personal files - Planner tasks and plans **Data operations**: ```javascript // Example: Get manager for approval routing GET https://graph.microsoft.com/v1.0/users/{id}/manager // Example: Create Teams meeting for process review POST https://graph.microsoft.com/v1.0/me/onlineMeetings // Example: Access SharePoint template GET https://graph.microsoft.com/v1.0/sites/{site}/drive/items/{id} ``` ### Power Platform connectivity Extend Copilot with Power Platform: **Power Automate flows**: - Trigger complex multi-system workflows - Connect to 1000+ external services - Handle approvals and notifications - Synchronize data across systems **Power Apps integration**: - Embed custom forms in tasks - Create mobile-friendly interfaces - Access on-premises data - Build no-code solutions **Power BI reporting**: - Generate workflow analytics - Create executive dashboards - Track KPIs automatically - Embed reports in tasks ### Compliance and governance Enterprise features that protect your data: **Information protection**: - Sensitivity labels apply to generated content - Encryption for data at rest and in transit - Rights management for documents - Watermarking for confidential files **Audit and monitoring**: - All Copilot actions logged in audit trail - Compliance center visibility - Alert policies for unusual activity - eDiscovery support for investigations **Data residency**: - Respects geographic boundaries - Complies with regional regulations - Maintains data sovereignty - Supports government clouds ### Advanced scenarios **Multi-language support** ``` Copilot automatically detects language from user context, translates workflow content, maintains terminology consistency, respects regional formats and regulations. ``` **Intelligent routing** ``` Based on: Out-of-office status, workload balance, skill matching, time zones, escalation rules from AD groups. ``` **Predictive automation** ``` Copilot learns from patterns: Suggests process improvements, predicts bottlenecks, recommends resource allocation, identifies compliance risks early. ``` ### Performance optimization **Reduce API calls**: - Cache frequently accessed data - Batch Graph API requests - Use delta queries for changes - Implement webhook subscriptions **Manage throttling**: - Respect Graph API limits - Implement exponential backoff - Use application permissions wisely - Monitor quota consumption ### Troubleshooting **"Copilot can't access Tallyfy"** - Verify API plugin installation - Check Azure AD app permissions - Review conditional access policies - Ensure user has Copilot license **"Data isn't syncing correctly"** - Check Graph API permissions - Verify sensitivity labels allow access - Review data loss prevention rules - Confirm network connectivity ### Licensing and costs **Required licenses**: - Microsoft 365 E3 or E5 - Copilot for Microsoft 365 (check Microsoft for current pricing) - Tallyfy subscription - Optional: Power Platform licenses **Cost optimization**: - Use existing Microsoft 365 investment - Share Copilot licenses for automation - Leverage included Power Automate flows - Minimize premium connector usage ### Getting started 1. **Admin setup**: Install Tallyfy API plugin from Microsoft admin center 2. **Configure permissions**: Grant necessary Graph API and Tallyfy permissions 3. **Create agent**: Build declarative agent for your use case 4. **Test integration**: Run pilot with single workflow 5. **Deploy organization-wide**: Roll out to all users with training Microsoft Copilot brings your entire Microsoft 365 environment into workflow automation. Every email, document, and Teams message becomes potential workflow fuel, while maintaining the enterprise security your IT team demands. ### Webhooks - **[Send emails using webhooks](https://tallyfy.com/products/pro/integrations/webhooks/how-can-i-send-emails-using-webhooks-in-tallyfy/)**: The system enables automatic custom email notifications through webhooks by connecting Tallyfy with middleware tools to trigger emails based on specific task completions or events within processes. ## Sending Custom Emails Using Webhooks You can use Tallyfy's [webhooks](/products/pro/integrations/webhooks/) feature, combined with a [middleware](/products/pro/integrations/middleware/) tool (like Zapier, Make, or Power Automate), to automatically send custom email notifications when specific events happen in your Tallyfy workflows - like when a task is completed or a process milestone is reached. ### What you need - A Tallyfy account (webhooks are usually available on paid plans). - An account with a middleware service (Zapier, Make, Power Automate, etc.). - Basic understanding of how webhooks work and how to set up workflows in your middleware tool. :::note[Choosing a Middleware Tool] Zapier works well for simple email notifications. Make.com or Power Automate offer more options if needed. Developers can also build custom webhook receivers for maximum flexibility. ::: ### General setup steps The exact steps depend on your middleware tool, but here's the general idea: #### Step 1: Get a Webhook URL from your Middleware Tool #### Step 2: Set up the Webhook in Tallyfy #### Step 3: Set up the Email Action in your Middleware Tool #### Step 4: Customize Your Email ### Testing and Turning It On - Test the whole setup by running a test process in Tallyfy and completing the trigger step. - Check if the email arrives and looks correct. - Once you're happy, turn ON your automation/workflow in the middleware tool. Now, every time that specific step is completed in your Tallyfy process, your custom email will be sent automatically. - **[Webhook scenarios](https://tallyfy.com/products/pro/integrations/webhooks/how-can-i-use-tallyfys-webhooks-feature/)**: Tallyfy webhooks automatically send JSON data to external systems when workflow events occur including process launches and task completions with the payload containing all accumulated data from the process up to that point enabling real-time integrations through middleware tools like Zapier. ## Common Ways to Use Tallyfy Webhooks Tallyfy's webhooks send data automatically to other systems when certain events happen in your workflows. Here are the main events that can trigger a webhook: ### Trigger: When a process is launched You can set up a webhook at the template level in Tallyfy. This webhook sends a notification *immediately* when someone launches a new process from that template, even before any tasks are done. * **Use Case**: Track new process starts in real-time (e.g., log every new client onboarding started in a spreadsheet or database). ### Trigger: When a specific task is completed You can set up a webhook on a specific step within a Tallyfy template. This webhook sends a notification only when *that particular task* is completed. * **Use Case**: Trigger follow-up actions in other systems when a key milestone is reached (e.g., when "Contract Signed" task is completed, send data to the finance system). ### Video examples These videos show practical ways to use webhooks, often with a middleware tool like Zapier: :::note[Middleware Choice] These examples might use Zapier, but the concepts work similarly with other middleware tools like Make.com or Power Automate, which often provide better value for complex integrations. ::: * **Send Task Data to a Spreadsheet** Shows how to automatically add form answers from a Tallyfy task to rows in a spreadsheet. * **Start a New Process When a Task Finishes** Shows how completing one task in Tallyfy can automatically launch a different process. * **Send Form Data from Multiple Steps** Demonstrates sending data collected across several steps to another service. * **Send an Email When a Task Finishes** Shows how to trigger a custom email notification upon task completion. ### Webhook payload data Webhooks send detailed information in JSON format. You can see an example of the data structure here: 📌 [Webhook-Sample.json](https://screenshots.tallyfy.com/Webhook-Sample.json) :::tip[Webhooks carry ALL data up to that point] **Important concept**: When a webhook fires, it carries ALL the information collected in the process up to that specific point - like a fishing line that pulls everything with it. This includes: - All form fields from the kick-off form - All form fields from every completed task before this one - The current task's data - Process metadata and context You don't need separate webhooks for each piece of data - one webhook gives you everything that's happened so far in the process. ::: #### Webhook Payload Structure The JSON payload sent by the webhook contains detailed information about the event. Key sections include: - **`this_task__*`**: Information about the specific task that triggered the webhook (e.g., `this_task__id`, `this_task__title`, `this_task__status`, `this_task__completed_by__email`, `this_task__completed_at`). - **`this_task__captures__*`**: Contains the values submitted to form fields within the completed task. The structure varies by field type (e.g., `this_task__captures__field_alias__value`). - **`next_task__*`**: Details about the next task that needs attention - specifically, the first visible incomplete task ordered by position number (e.g., `next_task__id`, `next_task__title`, `next_task__owners__users`). Visible means not auto-skipped. Incomplete includes in-progress tasks. Returns `null` if all tasks are completed. - **`process__*`**: Information about the overall process instance (e.g., `process__id`, `process__name`, `process__status`, `process__created_at__date`). - **`process__prerun__*`**: Contains values submitted in the kick-off form fields for the process. - **`process__process_forms__*`**: Contains values for *all* form fields across *all* tasks in the process up to that point. - **`template__*`**: Details about the template the process was launched from (e.g., `template__id`, `template__title`, `template__version`). Refer to the sample JSON file linked above for the complete structure and specific field names. ### Date Formats Tallyfy lets you choose between two standard date formats for the dates included in webhook data. You select this when setting up the webhook. ![Date format human-readable](https://screenshots.tallyfy.com/tallyfy/pro/webhooks-date-format-human-readable.png) ![Date format ISO](https://screenshots.tallyfy.com/tallyfy/pro/webhooks-date-format-iso.png) ### Security Note Tallyfy webhooks include a special header called `X-Tallyfy-OrgID` which contains your unique organization ID. The system receiving the webhook can check this header for an extra layer of validation to ensure the message genuinely came from your Tallyfy account. ![X-Tallyfy-OrgID header](https://screenshots.tallyfy.com/tallyfy/pro/webhooks-x-tallyfy-orgid-header.png) ### Handling duplicate events :::caution[Webhooks can fire multiple times] Be aware that webhooks might fire more than once for the same event. For example, if a task is completed, then reopened and completed again, you'll receive multiple webhook notifications. Your receiving system should implement [idempotency handling](/products/pro/integrations/handling-idempotency-in-webhooks-and-api/) to prevent processing the same event multiple times. ::: - **[Details about webhooks](https://tallyfy.com/products/pro/integrations/webhooks/how-to-set-up-webhooks-in-tallyfy/)**: Tallyfy webhooks automatically transmit JSON data to external URLs when workflow events occur at either the template level (firing on any step completion or process launch) or step level (firing only for specific task completions) and include retry logic for failed deliveries along with organizational ID headers for security validation. ## Webhook Configuration Guide Tallyfy webhooks are automated messages sent to external systems when specific events occur in your workflows. They transmit JSON data packets to predefined URLs, enabling real-time integration with other applications without manual intervention. This guide explains how to configure and implement webhooks in Tallyfy and avoid the common pitfalls that trip people up. ### Understanding webhook types Tallyfy offers two webhook configuration levels: #### Template-level webhooks Template-level webhooks trigger when **any step** within a process is completed. They also trigger when a process is initially launched, before any tasks are even completed. They transmit the complete process data, including all form fields and step statuses. Think of these as the "firehose" option - you get everything. **Use cases:** - Track overall process progress in external systems - Update dashboards when any step changes - Trigger full data exports - Capture new process launches in external systems #### Step-level webhooks Step-level webhooks trigger when a **specific step** is completed. They provide targeted integration for individual tasks within a process. These are more surgical - only fire when that particular step is done. **Use cases:** - Send notifications at critical process milestones - Trigger follow-up actions in other systems - Export specific form field data collected at a particular step ### How webhook events flow This diagram shows how Tallyfy sends webhook data to external systems when events occur in your workflows. [Diagram removed for brevity] **What to notice:** - **Two trigger types**: Template-level webhooks fire on ANY step completion or process launch, while step-level webhooks only fire for specific steps - **Retry mechanism**: Failed webhook deliveries automatically retry up to 3 times with exponential backoff (1 minute, 5 minutes, 15 minutes) to handle temporary network issues - **Security validation**: The X-Tallyfy-OrgID header authenticates webhook requests - always validate this in your middleware to prevent processing unauthorized webhooks ### Configuring template-level webhooks ### Configuring step-level webhooks ### Implementation example: Slack notifications This example demonstrates how to send automated notifications to a Slack channel when an employee completes an onboarding process in Tallyfy. #### Requirements - Tallyfy account with Professional or Enterprise plan - Middleware account (such as Make.com, Power Automate, n8n, or Zapier) - Slack workspace with administrative access :::note[Choosing the Right Middleware] For production integrations, we recommend comparing different [middleware platforms](/products/pro/integrations/middleware/) based on your needs. Popular options include **n8n**, **Make**, **Microsoft Power Automate**, and Zapier - each with different pricing models and capabilities. For maximum control and flexibility, especially if you have development resources, consider using Tallyfy's [Open API](/products/pro/integrations/open-api/) to build custom integrations that use AI to generate code for serverless functions. ::: #### Step 1: Configure middleware webhook receiver #### Step 2: Configure Slack message action #### Step 3: Configure Tallyfy webhook #### Step 4: Test the integration ### Security considerations For webhook security, Tallyfy includes the `X-Tallyfy-OrgID` header in all webhook requests. You can use this header to verify that incoming webhooks are legitimate by checking against your organization's ID - you definitely don't want to process random webhook spam. ![X-Tallyfy-OrgID header](https://screenshots.tallyfy.com/tallyfy/pro/webhooks-x-tallyfy-orgid-header.png) :::warning[Important: Handle duplicate webhook events] Webhooks can fire multiple times for the same event. For example, when a task is completed and then reopened and completed again, you'll receive multiple webhook notifications. Always implement [idempotency handling](/products/pro/integrations/handling-idempotency-in-webhooks-and-api/) to prevent duplicate actions in your integrated systems. Handling duplicates from the start is much easier than debugging why things ran twice later. ::: ### Troubleshooting webhook issues **Webhooks not firing?** Here's how to diagnose: 1. **Verify the URL is correct** - Copy and paste it fresh, don't type it 2. **Check URL accessibility** - Test your webhook URL with a tool like RequestBin or Postman first 3. **Confirm webhook is enabled** - Both the toggle AND the URL field must be set 4. **Test with a simple receiver** - Use webhook.site or RequestBin to verify Tallyfy is sending data 5. **Check for HTTPS** - Many webhook receivers require HTTPS, not HTTP 6. **Look for authentication requirements** - Your receiver might be rejecting unauthenticated requests 7. **Verify process completion** - Webhooks only fire when steps are actually completed 8. **Check retry attempts** - Look for delayed delivery (1, 5, 15 minutes after initial failure) :::tip[Testing webhooks] **Always test with webhook.site first**. Go to webhook.site, get a unique URL, use it in Tallyfy, then complete a task. You'll see exactly what data Tallyfy sends. Once you confirm data is flowing, switch to your real webhook URL. ::: ### Best practices - Use HTTPS URLs for webhook destinations (HTTP is asking for trouble) - Implement webhook authentication in your receiving system - Test webhooks thoroughly before relying on them in production (seriously, test them) - Monitor webhook delivery using your middleware platform's logging tools - Consider implementing retry logic for failed webhook deliveries - Use webhook.site or RequestBin for initial testing before connecting to production systems - Always validate the payload structure - external systems change without warning - **[Webhook payload structure](https://tallyfy.com/products/pro/integrations/webhooks/webhook-payload-structure/)**: Tallyfy webhooks deliver JSON payloads with different structures for process-level events (launches/completions) and task-level events (task completions) containing complete workflow data form fields guest access links and task assignment information to enable real-time integration with external systems. ## Understanding webhook payload structure When Tallyfy sends a webhook to your endpoint, it delivers a JSON payload containing complete data about the event. The exact structure varies based on webhook type - **process-level webhooks** (fired when a process launches or completes) versus **task-level webhooks** (fired when a specific task completes). This reference shows the complete, verified structure produced by Tallyfy's actual API code, not theoretical examples. ## Process-level webhook payload Process-level webhooks fire when someone launches a new process or when a process completes. These webhooks include the full process state and all kick-off form data. ### Top-level structure ``` Process Webhook Payload ├── Process Information (from RunTransformer) │ ├── id, increment_id, name, summary │ ├── status, progress, whole_progress │ ├── checklist_id, checklist_title │ ├── created_at, started_at, completed_at │ ├── owner_id, started_by │ ├── collaborators (array of user IDs) │ └── Kick-off form data │ ├── prerun (structured form field values) │ ├── prerun_status, prerun_completed_at │ └── prerun_submitted_by │ ├── process-tasks │ └── Map of task alias => task ID │ ├── ko-form-fields │ └── Map of field alias => field value │ ├── guest-links ⭐ NEW │ └── Map of guest email => {link_for_guest: URL} │ └── launcher └── User who launched the process ``` ### Complete example ```json { "id": "abc123def456ghi789jkl012mno345pq", "increment_id": 1234, "checklist_id": "template789xyz123abc", "checklist_title": "Vendor Contract Review Workflow", "name": "Vendor Contract Review - ACME Corp", "summary": "Complete vendor contract review and approval workflow", "status": "in-progress", "progress": 60, "whole_progress": 60, "started_by": "user123abc456", "owner_id": "user123abc456", "prerun": { "vendor-name": "Widget Suppliers Inc", "contract-type": "Service Agreement", "estimated-value": "50000", "urgency": "normal" }, "prerun_status": "completed", "prerun_completed_at": "2025-10-01T09:15:00Z", "prerun_completed_by": "user123abc456", "prerun_length": 4, "created_at": "2025-10-01T09:00:00Z", "started_at": "2025-10-01T09:15:00Z", "last_updated": "2025-10-02T14:30:00Z", "completed_at": null, "collaborators": ["user123", "user456", "user789"], "late_tasks": 0, "due_soon": true, "due_date": "2025-10-15T17:00:00Z", "users": [ {"user_id": "user123", "full_name": "John Smith"}, {"user_id": "user456", "full_name": "Jane Doe"} ], "groups": [ {"group_id": "group123", "name": "Legal Team"} ], "process-tasks": { "initial-review": "task001abc", "legal-review": "task002def", "review-contract": "task003ghi", "execute-contract": "task004jkl" }, "ko-form-fields": { "vendor-name": "Widget Suppliers Inc", "contract-type": "Service Agreement", "estimated-value": "50000", "urgency": "normal" }, "guest-links": { "external.reviewer@vendor.com": { "link_for_guest": "https://go.tallyfy.com/guest-all-task/org789xyz123/guestcode123abc" }, "compliance@vendor.com": { "link_for_guest": "https://go.tallyfy.com/guest-all-task/org789xyz123/guestcode456def" } }, "launcher": { "id": "user123abc456", "email": "john@acmecorp.com", "full_name": "John Smith" } } ``` ## Task-level webhook payload Task-level webhooks fire when a specific task completes. These contain detailed information about the completed task, all process data collected so far, and the next task that needs attention. **What is `next_task`?** The first visible incomplete task ordered by position number. Visible means not auto-skipped by automation rules. Incomplete means not yet completed (includes tasks that are in-progress). Returns `null` if all tasks in the process are completed. ### Top-level structure ``` Task Webhook Payload ├── this_task │ ├── id, title, alias, status, summary │ ├── deadline, position │ ├── completed_at, completed_by │ ├── owners (users array + guests array) │ ├── captures (form fields in THIS task) │ │ └── {timeline_id: {alias, label, value}} │ └── assets (files uploaded to this task) │ ├── launcher │ └── User who launched the process │ ├── completer │ └── User who completed this task │ ├── process-tasks │ └── Map of task alias/id => task ID │ ├── form-fields │ └── ALL form fields from ALL tasks (flat structure) │ └── {field_alias: value} │ ├── template │ └── id, title, alias, summary │ ├── process │ ├── id, organization_id, name, summary │ ├── status, progress, created_at │ ├── ClientURL (link to process in Tallyfy) │ ├── prerun (kick-off form values) │ ├── process_forms (all fields by step_id) │ │ └── {step_id: {timeline_id: {alias, label, value}}} │ └── tags │ ├── guest-links ⭐ NEW │ └── Map of guest email => {link_for_guest: URL} │ └── next_task ├── id, title, alias, status ├── summary, position, deadline ├── owners (users + guests) └── captures (empty until task is worked on) ``` ### Complete example ```json { "this_task": { "id": "task003ghi789xyz", "title": "Review Contract", "alias": "review-contract", "status": "completed", "summary": "Review the vendor contract for accuracy", "deadline": "2025-10-15T17:00:00Z", "position": 3, "completed_at": "2025-10-02T14:30:00Z", "completed_by": { "id": "user123", "email": "john@acmecorp.com", "full_name": "John Smith" }, "captures": { "capture123timeline": { "alias": "contract-value", "label": "Contract Value", "value": "50000" }, "capture456timeline": { "alias": "approval-notes", "label": "Approval Notes", "value": "All terms look good. Approved for signature." } }, "owners": { "users": [ { "id": "user123", "email": "john@acmecorp.com", "full_name": "John Smith" } ], "guests": [ "external.reviewer@vendor.com" ] }, "assets": [ { "id": "asset123", "filename": "signed-contract.pdf", "version": "1", "public_link": "https://api.tallyfy.com/organizations/org789/file/asset123/dl" } ] }, "launcher": { "id": "user123", "email": "john@acmecorp.com", "full_name": "John Smith" }, "completer": { "id": "user123", "email": "john@acmecorp.com", "full_name": "John Smith" }, "process-tasks": { "initial-review": "task001abc", "legal-review": "task002def", "review-contract": "task003ghi", "task004jkl": "task004jkl" }, "form-fields": { "initial-review-notes": "Contract appears standard. Needs legal review.", "risk-assessment": "Low", "legal-review-status": "Approved", "contract-value": "50000", "approval-notes": "All terms look good. Approved for signature.", "approval-date": "2025-10-02" }, "template": { "id": "template123abc", "title": "Vendor Contract Review Workflow", "alias": "vendor-contract-review", "summary": "Standard workflow for reviewing and approving vendor contracts" }, "process": { "id": "run123abc456", "organization_id": "org789xyz123", "name": "Vendor Contract Review - ACME Corp", "summary": "Complete vendor contract review and approval workflow", "status": "in-progress", "progress": 60, "created_at": "2025-10-01T09:00:00Z", "ClientURL": "https://go.tallyfy.com/tracker/run123abc456", "prerun": { "vendor-name": "Widget Suppliers Inc", "contract-type": "Service Agreement", "estimated-value": "50000" }, "process_forms": { "step001": { "capture001timeline": { "alias": "initial-review-notes", "label": "Initial Review Notes", "value": "Contract appears standard." } }, "step002": { "capture002timeline": { "alias": "legal-review-status", "label": "Legal Review Status", "value": "Approved" } } }, "tags": [ { "id": "tag123", "name": "High Priority", "color": "#FF6B6B" } ] }, "guest-links": { "external.reviewer@vendor.com": { "link_for_guest": "https://go.tallyfy.com/guest-all-task/org789xyz123/guestcode123abc" }, "compliance@vendor.com": { "link_for_guest": "https://go.tallyfy.com/guest-all-task/org789xyz123/guestcode456def" } }, "next_task": { "id": "task004jkl", "title": "Execute Contract", "alias": "execute-contract", "status": "not-started", "summary": "Send final contract for execution", "position": 4, "deadline": "2025-10-20T17:00:00Z", "captures": {}, "owners": { "users": [ { "id": "user789", "email": "legal@acmecorp.com", "full_name": "Legal Team" } ], "guests": [] } } } ``` ## Guest links feature The `guest-links` object provides direct access URLs for all guest assignees in a process. This feature enables external systems to send personalized emails or SMS notifications to guests with direct links to their assigned tasks. ### Structure ```json "guest-links": { "guest.email@company.com": { "link_for_guest": "https://go.tallyfy.com/guest-all-task/{org_id}/{guest_code}" } } ``` ### Key characteristics - **Included in both webhook types**: Process-level and task-level webhooks - **All unique guests**: Includes every unique guest assigned anywhere in the process - **Direct access**: Links bypass login - guests click and see their assigned tasks - **Persistent codes**: Guest codes remain stable across the process lifecycle ### Common use cases - **Custom email notifications**: Build your own notification system using Zapier/Make - **SMS integration**: Send task reminders via Twilio with direct access links - **CRM integration**: Update external CRM records with guest task links - **Client portals**: Embed guest task links in customer-facing dashboards ## Form field structures Form fields appear in webhooks using different structures depending on context. ### In `this_task.captures` - detailed structure Task-specific form fields use the complete structure with timeline IDs as keys: ```json "captures": { "capture_timeline_123": { "alias": "contract-value", "label": "Contract Value", "value": "50000" }, "capture_timeline_456": { "alias": "approval-notes", "label": "Approval Notes", "value": "All terms look good." } } ``` ### In `form-fields` - flat structure All process form fields use a simplified flat structure with aliases as keys: ```json "form-fields": { "contract-value": "50000", "approval-notes": "All terms look good.", "initial-review-notes": "Contract appears standard.", "legal-review-status": "Approved" } ``` ### In `process.process_forms` - organized by step Form fields grouped by which step they belong to: ```json "process_forms": { "step001": { "capture_timeline_001": { "alias": "initial-review-notes", "label": "Initial Review Notes", "value": "Contract appears standard." } }, "step002": { "capture_timeline_002": { "alias": "legal-review-status", "label": "Legal Review Status", "value": "Approved" } } } ``` ## Date field formatting Date fields in captures respect your organization's webhook date format setting. Tallyfy supports two formats: **ISO 8601 format** (default): ```json "start-date": { "alias": "start-date", "label": "Contract Start Date", "value": "2025-10-15" } ``` **Localized format** (if configured as `d/m/Y h:i A T`): ```json "start-date": { "alias": "start-date", "label": "Contract Start Date", "value": "15/10/2025 09:00 AM UTC" } ``` The format applies to all date fields across the webhook payload. ## Task assignment information Task owners appear in the `owners` object containing both organization members and external guests. ```json "owners": { "users": [ { "id": "user123", "email": "john@acmecorp.com", "full_name": "John Smith" }, { "id": "user456", "email": "jane@acmecorp.com", "full_name": "Jane Doe" } ], "guests": [ "external.reviewer@vendor.com", "compliance@vendor.com" ] } ``` **Important differences**: - `users` contains full objects with ID, email, and name - `guests` contains only email addresses as strings - Use `guest-links` to get access URLs for guests ## Common integration patterns ### Sending custom emails to guests Use the `guest-links` object to send personalized emails: ```javascript // In your webhook handler (e.g., Zapier, Make, n8n) const guestLinks = webhookPayload['guest-links']; for (const [email, linkData] of Object.entries(guestLinks)) { sendEmail({ to: email, subject: `New task assigned: ${webhookPayload.this_task.title}`, body: `You have a new task. Click here to access: ${linkData.link_for_guest}` }); } ``` ### Extracting all collected data Get all form data collected across the entire process: ```javascript // Flat structure - simplest for most integrations const allFormData = webhookPayload['form-fields']; // Example: { "contract-value": "50000", "approval-notes": "..." } // Or get kick-off form data specifically const kickoffData = webhookPayload.process.prerun; // Example: { "vendor-name": "Widget Suppliers Inc", ... } ``` ### Triggering follow-up actions Use the `next_task` object to prepare for upcoming steps: ```javascript const nextTask = webhookPayload.next_task; if (nextTask && nextTask.title === "Execute Contract") { // Prepare contract execution system // Notify legal team // Update external tracking system } ``` ### Document management - **[File request links](https://tallyfy.com/products/pro/integrations/document-management/file-request-links/)**: File request links enable secure document collection from external users by generating unique upload URLs that allow anyone to submit files directly to your document management system without requiring account access or system permissions. ## Using file request links for secure document collection File request links solve a common workflow challenge - collecting documents from people who don't have access to your systems. Whether you're gathering tax documents from clients, medical records from patients, or contracts from vendors, these links provide a secure upload path without compromising your document security. The beauty lies in simplicity. Your document management system generates a unique link. Anyone with that link can upload files to a designated folder. They don't need an account, don't see other files, and can't access your broader system. Meanwhile, you maintain complete control over document storage, access, and compliance. ## How file request links work with Tallyfy ## Real-world example A legal firm uses this approach daily. Here's their workflow: The firm launches a new client onboarding process in Tallyfy. During launch, they generate unique Box file request links for each document type - contracts, identification documents, financial records. These links get stored in text fields. When the client receives their tasks, they see clear instructions: "Upload your documents here: [link]". The client clicks, uploads directly to the firm's Box account, and the documents land in the correct client folder. The law firm maintains attorney-client privilege while the client has a smooth experience. ## Setting up your workflow To implement file request links in your Tallyfy workflows, you need three components: **Template configuration** - Add short text form fields to capture the file request URLs during process launch. **Variable insertion** - Use variables to dynamically insert these URLs into task descriptions or form instructions. **Clear instructions** - Write task descriptions that explain what documents to upload and provide the link prominently. ## Security benefits File request links provide multiple layers of security: **No account required** - External users upload without creating accounts or remembering passwords. **Limited access** - Uploaders can't see, edit, or download existing files in your system. **Time limits** - Most DMS platforms let you set expiration dates on upload links. **Audit trails** - Your DMS tracks who uploaded what and when. **Compliance maintained** - Documents stay within your compliant infrastructure. ## Common use cases ### Legal services Collecting evidence, contracts, and identification documents from clients while maintaining privilege. ### Healthcare Gathering medical records, insurance cards, and consent forms from patients per HIPAA requirements. ### Financial services Obtaining tax documents, bank statements, and investment records for account opening. ### Human resources Collecting resumes, references, and onboarding paperwork from new hires. ### Real estate Gathering property documents, inspection reports, and closing paperwork from buyers and sellers. ## Best practices **Generate unique links** - Create fresh upload links for each process instance to maintain document separation. **Set expiration dates** - Configure links to expire after a reasonable timeframe to prevent unauthorized late uploads. **Name folders clearly** - Use consistent folder naming in your DMS that matches your process structure. **Provide examples** - In your task instructions, specify exactly what documents you need and acceptable formats. **Test the flow** - Run through the entire process as an external user would to ensure smooth operation. ## Choosing your DMS platform Different platforms offer varying levels of file request functionality: Not all platforms have native file request features. Google Drive, for instance, requires third-party tools to enable anonymous uploads. Consider your platform's capabilities when designing your workflow. ## Automation possibilities Advanced implementations can automate link generation: - Use your DMS API to create folders and generate links programmatically - Trigger link creation through webhooks when processes launch - Store links automatically in Tallyfy via API - Send links directly to recipients through automated emails This removes manual steps but requires technical setup. ## Troubleshooting common issues **Links not working** - Verify the link hasn't expired and the destination folder still exists. **Upload failures** - Check file size limits and accepted formats in your DMS settings. **Access problems** - Ensure your DMS allows anonymous uploads and "Anyone" links are enabled. **Missing files** - Confirm uploads completed successfully and check the correct folder in your DMS. ## Getting started Ready to implement file request links? Start by checking if your document management system supports this feature, then follow our platform-specific guides below for detailed setup instructions. ### File request links - **[Dropbox file requests](https://tallyfy.com/products/pro/integrations/document-management/file-request-links/dropbox/)**: Dropbox file requests provide a simple way to collect documents for Tallyfy workflows by allowing anyone to upload files directly to your Dropbox folder without requiring an account while maintaining security and organization through unique unguessable URLs and customizable folder destinations. ## Creating Dropbox file requests for Tallyfy workflows Dropbox offers one of the most straightforward file request implementations. Anyone can upload files to your Dropbox without needing an account, and you control exactly where those files land. ## Prerequisites You'll need a Dropbox account with file request capabilities: - **Basic/Plus/Family plans**: Can request files up to 2 GB each - **Professional/Business plans**: Can request files up to 250 GB each - **Business plans**: Additional options for deadlines and password protection ## Creating your first file request ## How uploaders experience it When someone clicks your file request link: 1. They see a simple upload page with your request title and description 2. They drag and drop files or click to browse 3. Optionally enter their name and email (Dropbox asks but doesn't require this) 4. Click **Upload** to send files directly to your folder Files appear immediately in your Dropbox folder with the uploader's name (if provided) as a filename prefix. ## Best practices for Tallyfy integration **Use descriptive titles** - Include the process name and instance identifier in your file request title. This helps you match uploads to specific workflows. **Create unique requests** - Generate a new file request for each process instance rather than reusing links. This maintains clear document separation. **Set reasonable deadlines** - If your plan supports it, set deadlines that align with your process timeline plus a buffer. **Monitor the folder** - Check your Dropbox regularly or set up notifications for new uploads. ## Managing multiple file types For processes requiring different document types, create separate file requests: ``` Passport Documents → /Client Files/[Name]/Passport/ Tax Documents → /Client Files/[Name]/Tax/ Medical Records → /Client Files/[Name]/Medical/ ``` Store each link in a different Tallyfy text field and reference them in the appropriate tasks. ## Security considerations Dropbox file requests provide solid security: - Uploaders can't see existing files in your folder - Each request has a unique, unguessable URL - You can close requests manually anytime - Business accounts can require passwords - All uploads are scanned for viruses ## Limitations to consider **File size limits** vary by plan - 2 GB for personal plans, 250 GB for business plans. **No upload confirmation** - Dropbox doesn't automatically notify you when files arrive unless you configure folder watching. **Name/email optional** - Uploaders can skip identifying themselves, though most provide this information. ## Automation options While Dropbox doesn't offer API access for creating file requests, you can: - Pre-create batches of file requests and store links in a spreadsheet - Use Dropbox folder actions to trigger notifications when files arrive - Integrate with Tallyfy webhooks to track when tasks complete ## Troubleshooting **"Request not found" error** - The request may have expired or been manually closed. Create a new request. **Files not appearing** - Check if uploads completed successfully. Large files may take time to sync. **Duplicate filenames** - Dropbox automatically adds numbers to duplicate filenames to prevent overwrites. ## Alternative: Shared folder approach For internal teams or trusted partners, consider Dropbox shared folders instead: 1. Create a shared folder in Dropbox 2. Generate a folder invite link 3. Store this link in Tallyfy 4. Users with Dropbox accounts can add files directly This provides more collaboration features but requires Dropbox accounts. ## Summary Dropbox file requests offer a reliable, user-friendly way to collect documents in Tallyfy workflows. The setup takes minutes, uploaders need no training, and your documents stay organized in your Dropbox folder structure. It's particularly effective for client-facing processes where simplicity matters most. - **[Box file requests](https://tallyfy.com/products/pro/integrations/document-management/file-request-links/box/)**: Box File Request enables enterprise-grade secure document collection from anyone through configurable upload links with features like identity verification email validation virus scanning and metadata collection making it ideal for regulated industries requiring Business plans or higher. ## Setting up Box file requests for document collection Box File Request gives you enterprise-grade security for collecting documents from anyone. The feature requires a Box Business plan but provides advanced controls perfect for regulated industries. ## Prerequisites - Box Business, Business Plus, or Enterprise account - Folder creation permissions in Box - Administrator approval if your organization restricts external sharing ## Creating a Box file request ## Enhanced security features Box provides enterprise-level security options: **Identity verification** - Require uploaders to sign in with a Box account (free accounts work). This captures their verified email address with every upload. **Email validation** - Even without Box login, you can require uploaders to provide and verify their email address. **Access controls** - Your Box administrator can enforce organization-wide policies for all file requests. **Virus scanning** - All uploads are automatically scanned before they're accessible. ## The uploader experience When someone accesses your Box file request: 1. They see your custom message explaining what files you need 2. If configured, they must sign in or verify their email 3. They complete any metadata fields you've required 4. They drag and drop or browse to select files 5. Box uploads the files and notifies you (if configured) ## Metadata collection Box's metadata feature adds powerful capabilities: ``` Example metadata setup: - Uploader Email: [Required] - Document Type: [Dropdown: Contract, Invoice, Receipt] - Reference Number: [Text field] - Description: [Text area] ``` This metadata appears with the uploaded files, making organization and searching easier. ## Integration with Tallyfy workflows **For simple collection** - Store one Box file request link per process and share it in multiple tasks. **For categorized uploads** - Create multiple file requests for different document types: - Financial documents → /Client Files/Financial/ - Legal documents → /Client Files/Legal/ - Identity documents → /Client Files/Identity/ **For maximum security** - Generate unique file requests for each process instance and set short expiration windows. ## Automation capabilities Box provides APIs for advanced automation: - Programmatically create file requests via Box API - Set up webhook notifications when files arrive - Automatically move uploaded files to permanent storage - Trigger Tallyfy API calls when uploads complete ## Managing file request links Track your active file requests: 1. Visit Box.com and navigate to your folder 2. Check the sharing panel to see active file requests 3. Disable links after the collection period ends 4. Review upload history in Box's admin console ## Best practices **Folder organization** - Create a clear folder hierarchy that mirrors your process structure. **Naming conventions** - Use consistent naming like `[Process]-[Date]-[Client]` for easy identification. **Regular cleanup** - Disable old file request links quarterly to maintain security. **Monitor usage** - Review Box's audit logs to track who's uploading files. ## Limitations **Business plan required** - File requests aren't available on personal Box accounts. **Single folder destination** - Each file request points to one folder (can't split uploads dynamically). **No conditional logic** - Can't show/hide metadata fields based on previous selections. ## Alternative: Box folder invites For trusted partners with Box accounts: 1. Create a Box folder 2. Click **Share** and invite collaborators 3. Set permissions to "Uploader" (can only add files) 4. Share the folder link through Tallyfy This approach provides more features but requires Box accounts. ## Troubleshooting **"Access denied" errors** - Check if your organization's admin has restricted file requests. **Missing metadata** - Ensure required fields are configured in the file request settings. **Upload failures** - Verify file size limits (5 GB default, configurable up to 250 GB). **Link not working** - Confirm the link is enabled and hasn't expired. ## Cost considerations Box file requests are included with Business plans but count toward your storage quota. Monitor usage if you're collecting large files regularly. ## Summary Box file requests excel in enterprise environments where security and compliance matter most. The ability to require authentication, collect metadata, and maintain detailed audit trails makes it ideal for regulated industries. While it requires a paid Box plan, the security features justify the investment for sensitive document workflows. - **[Google Drive file requests](https://tallyfy.com/products/pro/integrations/document-management/file-request-links/google-drive/)**: Google Drive lacks native file request functionality but reliable workarounds exist through third-party tools like FileDrop and File Request Pro that create upload forms connecting to your Drive or using Google Forms with limitations requiring user authentication. ## File requests for Google Drive Here's the reality - Google Drive doesn't have a built-in file request feature. Unlike Dropbox or Box, you can't generate a link that lets people upload files without a Google account. But don't worry. Several reliable workarounds exist, from third-party tools to creative uses of Google Forms. ## Understanding the limitation Google requires authentication for file uploads. When you share a folder for uploads, recipients must: - Have a Google account - Sign in to access the folder - Have explicit upload permissions This creates friction for external document collection, especially from clients or vendors who might not have Google accounts. ## Option 1: Third-party file request tools Several services bridge this gap by creating upload forms that connect to your Google Drive. ### FileDrop FileDrop creates professional upload forms that save directly to your Google Drive: **Pricing**: Free tier available with limitations, paid plans for higher volumes. ### File Request Pro File Request Pro offers similar functionality with additional features: - Custom branding and logos - Multiple file type restrictions - Size limit controls - Email notifications on upload - Metadata collection fields **Setup**: Connect Google Drive, create request, copy link to Tallyfy. ### Other alternatives - **JotForm**: Form builder with Google Drive integration - **Formfacade**: Converts Google Forms to allow file uploads - **Upload Files to Drive**: Simple, free Chrome extension ## Option 2: Google Forms with file upload Google Forms can collect files, but with significant limitations: **Critical limitation**: Uploaders must sign in with a Google account. This defeats the purpose for many external collection scenarios. ## Option 3: Shared folder with managed access For situations where Google accounts are acceptable: Users need Google accounts but can upload directly to your folder. ## Option 4: Google Workspace automation For organizations with Google Workspace, use Apps Script: ```javascript // Sample Apps Script for file upload endpoint function doPost(e) { var folder = DriveApp.getFolderById('FOLDER_ID'); var blob = Utilities.newBlob( Utilities.base64Decode(e.parameter.data), e.parameter.mimeType, e.parameter.fileName ); folder.createFile(blob); return ContentService.createTextOutput('Success'); } ``` Deploy as a web app to create a custom upload endpoint. Requires technical setup but provides full control. ## Comparing third-party solutions | Feature | FileDrop | File Request Pro | JotForm | Google Forms | |---------|----------|-----------------|---------|--------------| | No account needed | ✓ | ✓ | ✓ | ✗ | | Free tier | ✓ | ✓ | ✓ | ✓ | | Custom branding | Paid | ✓ | ✓ | Limited | | File size limits | 5 GB | 5 GB | 1 GB | 10 GB | | Metadata fields | ✓ | ✓ | ✓ | ✓ | | Direct to Drive | ✓ | ✓ | ✓ | ✓ | ## Security considerations When using third-party tools: **Data flow** - Files pass through the third-party service before reaching Google Drive. Ensure the service meets your security requirements. **Access scope** - Review what Google Drive permissions you're granting. Limit to specific folders when possible. **Compliance** - Verify the tool meets your industry's compliance standards (HIPAA, GDPR, etc.). **Vendor stability** - Choose established services with clear data handling policies. ## Best practices for implementation **Test thoroughly** - Try the complete upload flow before adding to production workflows. **Provide clear instructions** - Tell uploaders exactly what file types and sizes are accepted. **Monitor your folder** - Set up Google Drive notifications for new files. **Regular cleanup** - Move processed files to archive folders to keep upload destinations organized. **Have a backup plan** - Keep alternative upload methods ready in case third-party services have issues. ## Cost-benefit analysis Consider these factors when choosing your approach: **Volume** - High-volume collection justifies paid tools with better features. **Security requirements** - Sensitive documents might require keeping everything within Google's ecosystem. **User base** - If most uploaders have Google accounts, native sharing might suffice. **Budget** - Free tools work for occasional use, but paid options offer reliability and support. ## Summary While Google Drive lacks native file request functionality, workable solutions exist. Third-party tools like FileDrop and File Request Pro provide the smoothest experience for external users. For internal workflows or when Google accounts are acceptable, folder sharing or Google Forms can work. Choose based on your security requirements, user base, and workflow volume. The extra step of using third-party tools is worth it if Google Drive is your primary document platform. You maintain your existing storage, permissions, and backup systems while adding the upload functionality you need. - **[SharePoint file requests](https://tallyfy.com/products/pro/integrations/document-management/file-request-links/sharepoint/)**: SharePoint and OneDrive file requests enable secure document collection from anyone without requiring Microsoft accounts by generating unique upload links that direct files to specified folders while maintaining security through upload-only access and automatic malware scanning and audit logging. ## Using SharePoint and OneDrive file requests SharePoint and OneDrive for Business share the same file request technology. This feature lets you collect files from anyone - they don't need a Microsoft account or access to your SharePoint site. It's built into Microsoft 365 and works seamlessly with existing SharePoint permissions. ## Prerequisites - SharePoint Online or OneDrive for Business account - Your administrator must enable file requests - "Anyone" link sharing must be allowed in your tenant - The feature isn't available for Office 365 Germany or 21Vianet ## Creating a file request in SharePoint ## Creating a file request in OneDrive ## What uploaders see The experience is intentionally simple: 1. They click your link and see a clean upload page 2. SharePoint asks for their first and last name (to identify uploads) 3. They select or drag files to upload 4. Files upload directly to your specified folder 5. They see a confirmation when complete Each uploaded file gets prefixed with the uploader's name for easy identification. ## Security and compliance SharePoint file requests maintain your security posture: **No access beyond upload** - Users can only add files, not view, edit, or delete existing content. **Audit trails** - All uploads are logged in SharePoint's audit system for compliance tracking. **Data location** - Files stay in your tenant's geographic region per your data residency settings. **Automatic scanning** - Microsoft Defender scans all uploads for malware. **Compliance inheritance** - Uploaded files inherit retention policies and sensitivity labels from the destination folder. ## Advanced configuration with Power Automate You can automate file request link generation: ``` Automated workflow example: 1. Tallyfy triggers Power Automate when process starts 2. Power Automate creates a new SharePoint folder 3. Generates a file request link for that folder 4. Updates Tallyfy process with the link via API 5. Sends email to recipient with upload instructions ``` This eliminates manual link creation while maintaining unique upload destinations per process. ## Integration patterns for Tallyfy **Pattern 1: Department-based collection** Create permanent file request links for each department: - HR uploads → /HR Submissions/ - Finance uploads → /Finance Documents/ - Legal uploads → /Legal Files/ **Pattern 2: Time-based organization** Generate monthly folders with corresponding file requests: - January → /Uploads/YYYY-01/ - February → /Uploads/YYYY-02/ **Pattern 3: Process-specific folders** Create unique folders and file requests per process instance for maximum organization. ## Managing file requests Monitor active file requests: 1. Go to the SharePoint document library 2. Click **Manage access** in the toolbar 3. View all active file request links 4. Stop sharing to disable specific links Your SharePoint admin can also view all file requests across the tenant for governance. ## Limitations to consider **Expiration settings** - Links expire based on admin configuration (typically 30 days). **File naming** - SharePoint adds the uploader's name as a prefix, which can't be disabled. **No metadata collection** - Unlike Box, you can't add custom fields to the upload form. **Character limits** - Some special characters in filenames may cause upload issues. ## Troubleshooting common issues **"This link has expired"** - File request links expire after the configured time. Create a new request. **"Access denied"** - Your admin may have disabled "Anyone" links. Contact IT to enable file requests. **Large file failures** - SharePoint supports files up to 250 GB, but network timeouts may affect very large uploads. **Missing uploads** - Check if files are in a subfolder or if the uploader's name prefix is causing confusion. ## Alternative: Teams integration For internal workflows, consider using Teams channels: 1. Create a Teams channel for document collection 2. Add a SharePoint library tab 3. Share the Teams channel link through Tallyfy 4. Internal users can drag and drop files directly This provides more collaboration but requires Teams access. ## Administrator requirements If file requests aren't working, your admin needs to: 1. Enable "Anyone" links in SharePoint admin center 2. Configure `OneDriveRequestFilesLinkEnabled` to `$true` 3. Set `OneDriveRequestFilesLinkExpirationInDays` (1-730 days) 4. Ensure your SharePoint site allows external sharing ## Summary SharePoint file requests integrate naturally with Microsoft 365 environments. While they lack some advanced features of dedicated tools, they're included with your existing licenses and maintain your Microsoft security and compliance standards. For organizations already invested in SharePoint, it's the logical choice for document collection workflows. ### Mcp server - **[Using Tallyfy MCP server with Google Gemini](https://tallyfy.com/products/pro/integrations/mcp-server/google-gemini/)**: Google Gemini connects to Tallyfy workflows through official MCP support announced in December 2025 enabling natural language process management via the Gemini CLI or Google Cloud's managed infrastructure with features like BigQuery analytics integration and multimodal document processing capabilities. :::note[MCP Client Compatibility] Google announced official MCP support in December 2025. Gemini now supports managed MCP servers for Google Cloud services and integrates with the broader MCP ecosystem through the Gemini CLI. MCP is governed by the Agentic AI Foundation under the Linux Foundation, with Google as a supporting member. ::: ## Overview Google Gemini brings powerful AI capabilities to Tallyfy workflows through MCP integration. With official MCP support announced in December 2025, Gemini users can now connect to Tallyfy's MCP server using the Gemini CLI or through Google Cloud's managed MCP infrastructure. This guide shows you how to set up the integration, what works well, and how to get the most out of Gemini with Tallyfy. ## Google Gemini MCP support status Here's the current state of MCP support in Gemini: - **Official support**: MCP announced December 2025 for Gemini models - **Managed MCP servers**: Google Cloud provides managed servers for Maps, BigQuery, Compute Engine, Kubernetes Engine - **Gemini CLI**: FastMCP integration for local MCP server connections - **Transport methods**: Streamable HTTP (aligned with industry standard) - **Apigee integration**: Translate standard APIs to MCP servers - **Planned rollout**: Cloud Run, Storage, AlloyDB, Cloud SQL, Spanner, Looker, Pub/Sub **Note:** Google is a supporting member of the Agentic AI Foundation, ensuring continued commitment to MCP standards. ## Prerequisites You'll need these before getting started: - Google Cloud account with Gemini API access - Tallyfy API key (from your Tallyfy organization settings) - Gemini CLI installed (for local MCP connections) - Basic familiarity with Google Cloud console ## Setting up Tallyfy MCP Server with Google Gemini ## Practical demonstrations ### Example 1: Task management via natural language **User prompt:** ``` Using Tallyfy, find all overdue tasks and create a summary grouped by assignee. ``` **Gemini with MCP will:** 1. Connect to Tallyfy's MCP server 2. Execute the `search_tasks` tool with overdue filter 3. Group results by assignee 4. Generate a formatted summary ### Example 2: Process analytics **User prompt:** ``` Analyze our "Customer Onboarding" processes from the last month and identify bottlenecks. ``` **Gemini with MCP will:** 1. Query process history using MCP tools 2. Calculate step completion times 3. Identify steps with longest durations 4. Provide optimization recommendations ### Example 3: Template optimization **User prompt:** ``` Review our "Invoice Processing" template and suggest improvements based on best practices. ``` **Gemini with MCP will:** 1. Retrieve template structure using `get_template` 2. Analyze step dependencies and automation rules 3. Compare against workflow best practices 4. Suggest specific optimizations ## Unique Gemini features ### 1. Thinking capabilities Gemini's extended thinking mode provides deeper analysis: - Multi-step reasoning for complex workflow decisions - Detailed explanations of recommendations - Consideration of edge cases and exceptions ### 2. Google Cloud integration Deep integration with Google's ecosystem: - **BigQuery**: Analyze Tallyfy data alongside your data warehouse - **Cloud Run**: Deploy custom MCP logic at scale - **Pub/Sub**: Event-driven workflow triggers ### 3. Multimodal capabilities Gemini can process multiple input types: - Analyze uploaded documents within workflow context - Process images for visual inspection workflows - Combine text and visual analysis for comprehensive reviews ### 4. Vertex AI Agent Development Kit Build sophisticated agents that combine Tallyfy with other services: - Multi-agent orchestration - Custom tool development - Enterprise governance and monitoring ## Limitations Some things to keep in mind: ### 1. Feature rollout **Current state**: MCP support is new (December 2025) **Limitations:** - Some managed MCP servers still rolling out - Regional availability varies - Enterprise features may require additional configuration ### 2. Text-based interface constraints Same as other AI platforms: - No visual process tracker display - Complex forms become text-based interactions - Real-time updates require explicit queries ### 3. Google Cloud dependencies For managed MCP servers: - Requires Google Cloud account - Some features need specific IAM permissions - Billing applies for Cloud usage ## Ideal use cases ### 1. Data-driven workflow optimization **Strength**: Combine BigQuery analytics with Tallyfy process data. **Example:** ``` Correlate customer support ticket data from BigQuery with our support process completion times in Tallyfy. Identify patterns and suggest process improvements. ``` ### 2. Multi-service automation **Strength**: Orchestrate across Google Cloud and Tallyfy. **Example:** ``` When a new document is uploaded to Cloud Storage, trigger the document review process in Tallyfy and notify the team via Gmail. ``` ### 3. Intelligent process monitoring **Strength**: Gemini's analytical capabilities for workflow insights. **Example:** ``` Monitor all active processes and alert me to any that are at risk of missing their SLA, with root cause analysis. ``` ## Security considerations 1. **Authentication** - OAuth 2.1 with PKCE for secure token exchange - Tokens stored securely in Google's infrastructure - Refresh tokens for persistent connections 2. **Data handling** - Data processed according to Google's AI policies - Enterprise controls via Vertex AI - Audit logging available in Cloud Logging 3. **Network security** - All traffic over HTTPS - VPC Service Controls for enterprise - Private connectivity options available ## Best practices 1. **Start with Gemini CLI**: Fastest way to test and iterate 2. **Use structured prompts**: Gemini performs best with clear, specific instructions 3. **Leverage thinking mode**: Enable for complex analytical tasks 4. **Monitor usage**: Track API calls and costs in Google Cloud Console 5. **Implement error handling**: Build retry logic for production integrations ## Future outlook Google's MCP roadmap includes: - **Expanded managed servers**: Cloud Run, Storage, AlloyDB, Cloud SQL, Spanner, Looker, Pub/Sub - **Apigee MCP translation**: Convert any API to MCP server automatically - **Enhanced Vertex AI integration**: Deeper agent development capabilities - **Enterprise governance**: Advanced security and compliance features As a founding member of the Agentic AI Foundation, Google is committed to the continued evolution of MCP as the industry standard. - **[Using Tallyfy MCP server with ChatGPT](https://tallyfy.com/products/pro/integrations/mcp-server/openai-chatgpt/)**: ChatGPT Enterprise Team and Education users can connect to Tallyfy through MCP servers to manage workflows using natural language with full read/write capabilities through Developer Mode though the text-based interface has significant limitations for visual workflows form interactions real-time collaboration and bulk operations making it best suited for complex searches analysis automation planning and template optimization while still requiring Tallyfy's native visual interface for process tracking collaboration and interactive form completion. :::note[MCP Client Compatibility] An MCP server can be used by any MCP client that supports it. ChatGPT now has full MCP support through "Apps" (formerly called "connectors" - renamed December 2025). You can use Tallyfy's MCP server with read/write capabilities, though the text-based UI has limitations. We'll show you what works and what doesn't. Tallyfy is building its own chat UI to fix these limitations - but start using MCP today for immediate value. ::: ## Overview ChatGPT Enterprise, Team, and Education users can connect to Tallyfy through MCP servers. It's a game-changer. You can manage your workflows using natural language - just type what you need and ChatGPT handles the technical details. This guide shows you exactly how to set up the integration, what it can (and can't) do, and whether it's right for your team. ## ChatGPT MCP support status ChatGPT's MCP implementation includes: - **Availability**: ChatGPT Pro, Plus, Team, Enterprise, and Education plans - **Access method**: Through Developer Mode and Apps (formerly "connectors" - renamed December 2025) - **Supported operations**: Full read/write via Developer Mode, read-only via Deep Research - **Authentication**: API key-based or OAuth 2.1 authentication - **Security**: User-managed MCP server connections with security warnings - **Apps SDK**: Build custom UIs alongside MCP servers for enhanced experiences **Note:** Developer Mode must be enabled in ChatGPT settings to use MCP servers in regular conversations. Apps can be created using OpenAI's Apps SDK for custom frontends. ## Prerequisites You'll need these before we start: - ChatGPT Enterprise, Team, or Education subscription - Tallyfy API key (available from your Tallyfy organization settings) - Access to create custom Deep Research connectors in ChatGPT - Basic understanding of API security best practices ## Setting up Tallyfy MCP Server with ChatGPT ## Practical demonstrations ### Example 1: Finding overdue tasks **User prompt:** ``` Using Tallyfy, find all overdue tasks assigned to the marketing team and summarize them by priority. ``` **ChatGPT with MCP will:** 1. Connect to Tallyfy MCP server 2. Execute `search_for_tasks` with overdue filter 3. Filter results by marketing team assignment 4. Organize findings by priority 5. Present a formatted summary ### Example 2: Analyzing template health **User prompt:** ``` Analyze our "Customer Onboarding" template in Tallyfy and suggest improvements for efficiency. ``` **ChatGPT with MCP will:** 1. Use `get_template` to retrieve template details 2. Execute `assess_template_health` for thorough analysis 3. Identify bottlenecks or redundant steps 4. Suggest specific optimizations 5. Provide actionable recommendations ### Example 3: Creating workflow documentation **User prompt:** ``` Generate documentation for our "Invoice Processing" workflow in Tallyfy, including all steps and form fields. ``` **ChatGPT with MCP will:** 1. Retrieve template structure using `get_template` 2. List all steps with descriptions 3. Document form fields for each step 4. Include automation rules 5. Format as readable documentation ## Limitations of text-based UI Here's the thing - ChatGPT's text interface hits some real walls with Tallyfy: ### 1. Form field interactions **Challenge**: Dropdown fields, multi-select options, and complex form inputs are difficult to represent in plain text. **Example limitation:** - Got a dropdown with 20+ options? ChatGPT shows them all as a wall of text. Good luck picking the right one. - Date pickers become "please type the date in YYYY-MM-DD format" - not exactly user-friendly - File uploads? Forget about it. The text interface can't handle them. ### 2. Visual workflow representation **Challenge**: ChatGPT cannot display Tallyfy's visual process tracker or workflow diagrams. **Impact:** - Can't see how steps flow from one to another - Real-time progress updates? Gone. - Dependencies between steps become a guessing game ### 3. Bulk operations **Challenge**: Managing multiple items simultaneously is inefficient in a conversational interface. **Example scenarios:** - Need to reassign 50 tasks? You're looking at typing 50 individual commands (or one really complex bulk instruction that might break) - Want to filter and sort a big list of processes? Hope you like reading through pages of text - Batch template updates happen in the dark - no visual confirmation until you check manually ### 4. Real-time collaboration **Challenge**: ChatGPT's turn-based interaction model doesn't support real-time updates. **Limitations:** - Your teammate just finished a task? You won't know until you ask again - Urgent notifications get buried in conversation history - Two people editing the same template means taking turns - no simultaneous work ## Major blockers for full Tallyfy functionality Let's be honest - some Tallyfy features just don't work well in ChatGPT: ### 1. Visual process tracker The **Tracker View** in Tallyfy gives you that bird's-eye view of all running processes - visual progress bars, color-coded statuses, the works. ChatGPT? Can't show you any of it. That makes it tough to: - Monitor overall process health at a glance - Identify bottlenecks across multiple workflows - Track SLA compliance visually - See process completion percentages ### 2. Template builder interface Creating and editing [templates](/products/pro/documenting/templates/) through ChatGPT? It's painful: - Cannot drag-and-drop to reorder steps - Difficult to visualize branching logic - Complex automation rules are hard to configure through text - No visual preview of the template structure ### 3. Advanced filtering and views Tallyfy's powerful filtering just doesn't translate to text: - Cannot save custom views - Multi-dimensional filtering requires complex natural language queries - No visual indicators for filter results - Sorting options are limited and cumbersome ### 4. Interactive analytics visualization Visual analytics in text-based chat? Not happening: - No charts or graphs visualization - Trend analysis requires textual descriptions - Performance metrics lack visual context - For visual analytics, connect your BI tools to [Tallyfy Analytics](/products/pro/integrations/analytics/) instead ## Ideal use cases for ChatGPT + Tallyfy MCP Where does ChatGPT actually shine with Tallyfy? Here are the sweet spots: ### 1. Natural language template search **Strength**: Finding relevant templates using conversational queries. **Example**: ``` "Find all templates related to employee onboarding that include background check steps" ``` ChatGPT searches template names, descriptions, and even the content inside steps. It finds what you're looking for in seconds. ### 2. Automated field generation **Strength**: Creating form fields based on process descriptions. **Example**: ``` "Add appropriate form fields to collect customer feedback in our support process" ``` ChatGPT looks at your process context and suggests fields that actually make sense - complete with the right validation rules. ### 3. What-if automation scenarios **Strength**: Testing automation logic before implementation. **Example**: ``` "If I set up an automation to assign tasks based on deal value, show me how it would route these 5 example deals" ``` ChatGPT runs the simulation without touching your live processes. Safe testing. ### 4. Process documentation updates **Strength**: Updating templates based on document changes. **Example**: ``` "Here's our updated SOX compliance procedure. Update our audit template to match these new requirements, highlighting what changed" ``` ChatGPT reads your document, figures out what changed, and updates your template accordingly. Pretty slick. ### 5. Template optimization from task patterns **Strength**: Identifying recurring ad-hoc tasks that should be formalized. **Example**: ``` "Analyze one-off tasks added to our hiring processes last month and suggest which should be added to the template" ``` ChatGPT spots the patterns and suggests which tasks deserve a permanent home in your template. You decide what makes the cut. ### 6. Complex query answering **Strength**: Answering specific questions about workflow data with citations. **Example**: ``` "Which step in our sales process has the longest average completion time, and which team members are fastest at completing it?" ``` ChatGPT digs through your data, crunches the numbers, and gives you the answer - complete with links to the specific [processes](/products/pro/tracking-and-tasks/processes/) it analyzed. ## Security considerations When connecting ChatGPT to Tallyfy: 1. **API key management** - Use dedicated service accounts with minimal required permissions - Rotate API keys regularly - Monitor API usage for anomalies 2. **Data sensitivity** - Review which templates and processes contain sensitive information - Consider creating ChatGPT-specific user roles with restricted access - Audit data access logs regularly 3. **Prompt injection risks** - Be cautious of templates or data that might contain prompt-like text - Verify unexpected ChatGPT behaviors - Report suspicious activity to both OpenAI and Tallyfy support ## Known issues and limitations Current limitations to be aware of: 1. **Deep Research is read-only**: Use Developer Mode for write operations - enable it in ChatGPT Settings → Beta Features → Developer Mode 2. **Apps SDK available**: For custom UIs alongside MCP servers, explore OpenAI's Apps SDK at developers.openai.com/apps-sdk 3. **Session timeouts**: Long-running queries may timeout after 60 seconds 4. **Context window limits**: Large template structures may exceed token limits 5. **No real-time updates**: Changes made in Tallyfy aren't reflected until next query 6. **Limited file handling**: Cannot process attachments or generate files 7. **No webhook support**: Cannot trigger or respond to Tallyfy webhooks 8. **Terminology note**: OpenAI renamed "connectors" to "apps" in December 2025 - some documentation may still reference the old terminology ## Best practices Want to get the most out of ChatGPT with Tallyfy? Follow these tips: 1. **Use specific queries**: Instead of "show me tasks," use "show me high-priority tasks assigned to John due this week" 2. **Batch related requests**: Combine multiple related queries in a single prompt for efficiency 3. **Use ChatGPT's analysis**: Ask for insights and patterns, not just data retrieval 4. **Create query templates**: Save effective prompts for common workflows 5. **Combine with native Tallyfy**: Use ChatGPT for analysis and planning, then execute in Tallyfy's visual interface ## Future outlook What's available now and coming next: - **Write capabilities**: Already available via Developer Mode - create and modify workflows through ChatGPT - **Apps SDK**: Build custom UIs alongside MCP servers for richer experiences - **OAuth 2.1 support**: Enhanced security with PKCE authentication flow - **Richer UI elements**: Improved representation of visual elements in text - **Real-time synchronization**: Live updates between ChatGPT and Tallyfy (coming soon) - **Multimodal support**: Potential for image and diagram generation Both OpenAI and Tallyfy are actively expanding MCP features. MCP is now governed by the Agentic AI Foundation under the Linux Foundation, ensuring continued industry-wide support. ## Conclusion ChatGPT with Tallyfy MCP Server is powerful for natural language workflow management - but it's not replacing Tallyfy's visual interface anytime soon. Think of them as partners. Use ChatGPT for: - Complex searches and analysis - Automation planning and testing - Bulk data queries and insights - Template optimization suggestions Continue using Tallyfy's native interface for: - Visual process tracking - Real-time collaboration - Template building and editing - Interactive form completion Together, they're unbeatable. - **[Using SSO with MCP servers](https://tallyfy.com/products/pro/integrations/mcp-server/sso-authentication/)**: SSO integration with MCP servers enables enterprise AI authentication by allowing users to authenticate once with their corporate identity provider and gain access to multiple integrated workflow tools through standardized OAuth 2.1 flows that delegate authentication to enterprise identity providers like Microsoft Entra ID Okta and Google Workspace while addressing challenges like repeated consent fatigue and shadow OAuth visibility through centralized profile systems and developer SDKs. :::note[Advanced Integration Topic] This article covers advanced authentication patterns for MCP servers using enterprise Single Sign-On (SSO) systems. While technically feasible, most implementations require custom development and careful security considerations. The concepts described here represent emerging patterns in the AI integration space. ::: ## Overview Single Sign-On (SSO) integration with Model Context Protocol (MCP) servers tackles one of enterprise AI's biggest headaches: **seamless authentication across multiple systems**. Think about it - instead of juggling separate credentials for each AI tool integration, SSO creates a unified identity experience. Your corporate credentials unlock access to all approved workflow tools. Simple. This approach completely changes how authentication works. Traditional models? They force each AI application to authenticate individually for every external service. It's exhausting. With SSO-backed MCP servers, you authenticate once with your corporate identity provider. That single session authorizes access to dozens of integrated tools - no more repeated login prompts interrupting your workflow. ## The authentication challenge in MCP Here's the thing: MCP servers don't know who you are by default. They just receive requests from AI agents. No identity, no context. This creates real authentication gaps when you're trying to access enterprise systems that need user credentials: **Traditional workarounds:** - Embedding API keys as environment variables - Using OAuth Device Authorization Flow for local servers - Manual token management per tool **Problems with current approaches:** - No scalability for multiple secure integrations - Shadow IT concerns with unmanaged API access - Compliance challenges in regulated industries - Poor user experience with repeated authentication prompts ## How SSO bridges the gap SSO integration with MCP uses standardized OAuth 2.1 flows. These flows delegate authentication to your enterprise identity providers - here's how it works: ### Interactive delegation flow 1. **User initiates connection**: AI agent requests access to a specific tool 2. **SSO redirect**: MCP server redirects user to corporate identity provider 3. **Corporate authentication**: User logs in with existing SSO credentials (including MFA, conditional access) 4. **Token exchange**: Identity provider returns authorization code, which MCP server exchanges for access token 5. **Secure API access**: MCP server uses resulting token to access target service APIs The following diagram illustrates how SSO authentication flows between your users, AI agents, MCP servers, and enterprise identity providers. [Diagram removed for brevity] **What to notice:** - **Step 4-5**: The identity provider validates corporate credentials including MFA and conditional access policies before issuing tokens - **Step 8-9**: The MCP server handles token exchange automatically - users never see or manage raw tokens - **Steps 10-13**: Once authenticated, the MCP server can make multiple API calls on behalf of the user without additional prompts ### Bearer token acceptance Want to skip the extra steps? Advanced implementations let MCP servers accept existing SSO tokens directly: - AI client presents valid OIDC ID token or access token from identity provider - MCP server verifies token authenticity and extracts user permissions - Server performs token exchange to obtain service-specific API credentials - Eliminates additional login prompts for already-authenticated users The result? Seamless access. ## Major identity provider support ### Microsoft Entra ID (Azure AD) **Strengths:** - Full OAuth 2.1 and OIDC support with PKCE - On-behalf-of (OBO) token exchange for Microsoft Graph APIs - Conditional Access Policies apply automatically to MCP connections - Native integration with Microsoft 365 and Azure services **Implementation approach:** ```javascript // Example MCP server configuration for Azure AD const azureAdConfig = { clientId: process.env.AZURE_CLIENT_ID, clientSecret: process.env.AZURE_CLIENT_SECRET, tenantId: process.env.AZURE_TENANT_ID, redirectUri: 'https://mcp-server.company.com/auth/callback', scopes: ['User.Read', 'Mail.Read', 'Calendar.Read'] }; ``` **Current limitations:** - Tokens primarily designed for Microsoft APIs - Can't directly issue Google API tokens - no native cross-provider token exchange - You'll need to manually register each MCP server as an app ### Okta **Strengths:** - Comprehensive OAuth 2.0 and device flow support - Custom authorization servers for API-specific scopes - Strong ecosystem integration capabilities - Active development of cross-domain authorization standards **Key features:** - Standard OIDC discovery endpoints (`.well-known/openid-configuration`) - Dynamic client registration support - Flexible token refresh policies - Integration with enterprise directories **Marketplace integration:** - Okta Integration Network (OIN) listing opportunity - Pre-configured settings for easier deployment - SCIM provisioning for automated user management ### Google Workspace Identity **Dual role capabilities:** - OAuth provider for Google services (Gmail, Drive, Calendar) - OIDC identity provider for third-party applications **Domain-wide delegation:** - Administrators can pre-authorize applications - Service accounts can impersonate users for API access - Eliminates per-user consent for approved tools **Enterprise controls:** - Admin-managed app whitelisting - Data access policies and restrictions - Integration with Google Workspace Marketplace ### OneLogin and other providers Good news - most enterprise identity providers support what you need: - SAML 2.0 and OIDC/OAuth 2.0 compatibility - Similar token exchange limitations (yes, they all have them) - Marketplace/catalog integration opportunities - Comparable security policy enforcement ## Current gaps and challenges ### Repeated consent fatigue **Problem**: Users face multiple OAuth consent flows for each tool integration, even when using the same SSO credentials underneath. **Real-world impact**: Picture this - an employee using an AI assistant that integrates email, calendar, Slack, GitHub, and Salesforce. Five separate login prompts. Every single time. ### Shadow OAuth visibility **Problem**: Token exchanges between AI applications and services often occur outside IT's direct oversight. **Compliance concerns**: - No centralized view of "App X has access to Data Y for User Z" - Difficulty tracking ongoing API access permissions - Challenges with access revocation during employee offboarding ### Implementation complexity **Problem**: Each MCP server developer must implement OAuth components (authorization endpoints, token management, client registration). **Developer burden**: Building secure OAuth flows isn't trivial. It requires specialized knowledge. Make a mistake, and you've introduced vulnerabilities. ### Token lifecycle management **Problem**: Coordinating token refresh, expiration, and revocation across multiple identity domains. **Technical challenges**: - No universal token exchange between different providers - Complex mapping of enterprise permissions to MCP tool access - Inconsistent revocation signal propagation ## Solution approaches ### Centralized profile system **Architecture**: Cloud service acts as universal integration broker, similar to [mcp.run's profile system](https://docs.mcp.run/blog/2025/05/14/mcp-sso/). **User experience**: 1. Connect all your tools once on a centralized dashboard 2. Tools get grouped into profiles (Work Profile, Personal Profile) 3. AI applications request access to your entire profile via single OAuth flow 4. One consent screen covers everything **Technical implementation**: - Bridge service becomes OAuth Authorization Server - Secure token vault stores encrypted API credentials - MCP proxy routes requests to appropriate services - Centralized audit logging and access control Clean. Efficient. ### Enterprise IdP extensions **Cross-app mediation**: Add-on or plugin for existing identity providers that handles inter-application authorization. **Example flow**: 1. AI application requests Slack access token from mediation service 2. Service validates user's identity with corporate IdP 3. Service checks admin-configured policies 4. If approved, service obtains Slack token on user's behalf 5. Token returned to AI application without user interaction **Governance benefits**: - Admin dashboard for approving/denying AI-to-app connections - Centralized policy enforcement - Comprehensive audit trails - Automated compliance reporting ### Developer SDK approach **Purpose**: Make OAuth implementation actually manageable for MCP server developers. **Features**: - Pre-built integrations for major identity providers - Automatic token refresh and error handling - Testing and validation tools - Consistent security patterns No more reinventing the wheel. **Example usage**: ```python from mcp_auth import SSO # Initialize with multiple IdP support sso = SSO(providers=['okta', 'azure_ad', 'google']) # Protect MCP route with minimal configuration @sso.require_auth(scopes=['email.read']) async def handle_email_request(user_context): # User identity and permissions automatically available return await fetch_user_emails(user_context.token) ``` ## Implementation strategies ### OAuth 2.1 standard compliance Here's what modern MCP implementations need to follow OAuth 2.1 guidelines: ### Security considerations **Token storage security**: - Use hardware security modules (HSMs) or encrypted key vaults - Implement short-lived access tokens with refresh mechanisms - Monitor for anomalous API usage patterns **Network security**: - Require HTTPS for all authentication endpoints - Implement rate limiting and DDoS protection - Use certificate pinning for high-security environments **Access control**: - Map SSO roles and groups to MCP tool permissions - Implement just-in-time access for sensitive operations - Support conditional access policies from identity providers ## Best practices for enterprises ### Governance and compliance **Establish clear policies**: - Define approved AI applications and integrations - Document data access requirements and limitations - Create approval workflows for new tool connections **Implement monitoring**: - Log all token exchanges and API access - Set up alerts for unusual access patterns - Schedule regular access reviews and permission audits Don't wait for an incident to discover gaps. ### User experience optimization **Minimize authentication friction**: - Use existing SSO sessions when possible - Group related tools into logical profiles - Provide clear consent descriptions **Support diverse client types**: - Web-based AI applications (authorization code flow) - Desktop applications (device authorization flow) - CLI tools and scripts (client credentials or device flow) ### Technical architecture **Design for scale**: - Implement token caching to reduce identity provider load - Use connection pooling for high-volume API access - Plan for geographic distribution of services **Ensure reliability**: - Implement circuit breakers for external API calls - Design graceful degradation when identity services unavailable - Maintain service status dashboards Your users expect 99.9% uptime. Plan accordingly. ## Integration with popular providers ### Microsoft ecosystem integration **Azure AD Gallery listing**: - Register as Enterprise Application - Support both OIDC and SAML if needed - Implement Microsoft Graph API integration **Copilot Studio compatibility**: - Leverage existing MCP connector framework - Use Entra ID authentication for connectors - Apply enterprise security controls automatically ### Okta Integration Network **OIN submission process**: 1. Create integration in Okta developer organization 2. Implement OIDC authentication flow 3. Add SCIM provisioning support if applicable 4. Submit for Okta review and certification **Value proposition**: - One-click configuration for Okta customers - Pre-validated security implementation - Automatic user lifecycle management ### Google Workspace Marketplace **Verification requirements**: - Google OAuth application verification - Privacy policy and data handling documentation - Minimal scope usage demonstration **Domain-wide installation**: - Admin consent for organizational deployment - Centralized permission management - Integration with Google's security policies ## Future outlook ### Emerging standards **Cross-domain authorization chaining**: The OpenID Foundation working groups are developing standards for seamless app-to-app authorization. Identity providers will mediate these connections. **Enhanced token exchange**: OAuth 2.0 extensions promise more flexible token exchange scenarios. Cross-provider scenarios included. **AI-specific authentication patterns**: New protocols optimized specifically for AI agent authentication and delegation scenarios are in development. ### Industry trends **User-driven integrations**: Shift from app-defined to user-controlled integration profiles that travel between AI applications. **Zero-trust architecture**: Integration of MCP authentication with broader zero-trust security frameworks. **Regulatory compliance**: Enhanced audit trails and governance features to meet evolving data protection requirements. ## Conclusion SSO integration with MCP servers represents a critical evolution in enterprise AI security. Yes, technical implementation requires careful planning and security considerations. But look at what you gain: - **Reduced authentication friction** for end users - **Centralized identity governance** for IT administrators - **Enhanced security posture** through corporate policy enforcement - **Improved compliance** with data protection regulations If you're implementing MCP-based AI workflows, prioritize SSO integration from day one. Use your existing identity provider investments. Plan for emerging cross-domain authorization standards. The landscape is ripe with opportunities - both for enterprises seeking secure AI integration and technology providers developing SSO-MCP bridging solutions. As standards mature and adoption grows, SSO-backed MCP authentication will become the foundation for trusted enterprise AI workflows. Get ahead of the curve. - **[Using Tallyfy MCP server with Claude (text chat)](https://tallyfy.com/products/pro/integrations/mcp-server/claude-anthropic/)**: Claude Desktop connects to Tallyfy through an MCP server middleware layer enabling natural language workflow management with features like Desktop Extensions for one-click installation and remote OAuth authentication while offering practical capabilities for task management process analysis documentation generation and intelligent routing despite limitations around visual interfaces real-time updates and complex form interactions. :::note[MCP Client Compatibility] You can use Tallyfy's MCP server with any MCP client. The major AI platforms now support MCP: - **OpenAI**: MCP support in Agents SDK, ChatGPT desktop integration with custom connectors for Team/Enterprise users - **Claude**: Desktop Extensions (.mcpb) for one-click installation, remote MCP servers with OAuth, encrypted credential storage - **Microsoft**: Native MCP in Copilot Studio with automatic tool integration, full tracing, Dataverse integration - **Google**: Gemini models support MCP via Vertex AI Agent Development Kit with thinking capabilities - **Slack**: Official MCP support with Real-time Search API and Enterprise+ AI features The MCP ecosystem has grown rapidly with thousands of community-built connectors. We're still building our own chat UI for optimal Tallyfy workflows. ::: ## Overview Claude Desktop pioneered MCP support, becoming the first AI assistant to offer native MCP integration. The current Claude model family includes: - **Claude Opus 4.5**: Flagship model with exceptional coding performance and sustained multi-hour reasoning - **Claude Sonnet 4**: Balanced performance with hybrid instant/extended thinking modes - **Claude Haiku 4**: Fast, efficient model for lighter tasks - **Claude Code**: Available with VS Code, JetBrains, and GitHub Actions support for seamless pair programming We'll walk you through setting up Tallyfy's MCP server with Claude Desktop, show you what works (and what doesn't), and help you get the most out of this integration. ## MCP architecture flow This diagram shows how Claude Desktop connects to Tallyfy through the MCP server middleware layer. [Diagram removed for brevity] **What to notice:** - The MCP server runs locally on your machine and uses stdio (standard input/output) for communication - not network protocols - API authentication happens once when the server starts, using the Bearer token from your environment variable - Claude automatically discovers available tools from the MCP server and displays them in the UI with the 🔨 icon :::warning[Important: Claude Desktop vs Claude Computer Use] This article covers **Claude Desktop's text-chat interface with MCP integration** - where you interact with Claude through natural language to access Tallyfy data via MCP servers. This is different from [Claude Computer Use](/products/pro/integrations/computer-ai-agents/vendors/claude-computer-use/), which allows Claude to visually perceive and control computer interfaces (mouse, keyboard, screenshots). **Key differences:** - **Claude Desktop + MCP** (this article): Text-based chat that connects to data sources and APIs - **Claude Computer Use**: Visual perception and control of desktop applications through screenshots and mouse/keyboard actions Both can work with Tallyfy, but serve different purposes: - Use **Claude Desktop + MCP** for data queries, analysis, and API-based automation - Use **Claude Computer Use** for automating visual UI tasks that require seeing and clicking interface elements ::: ## Claude Desktop MCP support status Claude Desktop's MCP implementation includes: - **Native support**: Built-in MCP client with full protocol support - **Desktop Extensions**: One-click .mcpb file installation - bundling entire MCP servers with dependencies into single packages - **Remote MCP servers**: Direct URL-based connection with OAuth 2.1 authentication, hosted on Cloudflare - **Transport methods**: Standard input/output (stdio) for local servers, **Streamable HTTP** for remote servers (SSE is deprecated - prefer Streamable HTTP) - **Security**: OS keychain integration (macOS Keychain, Windows Credential Manager) for encrypted credential storage - **All Claude plans**: Available for Free, Pro, Max, Team, and Enterprise tiers - **Operating systems**: macOS and Windows fully supported - **Dynamic tool discovery**: Automatic detection and display of available MCP tools with the hammer icon - **MCP governance**: MCP is now governed by the Agentic AI Foundation under the Linux Foundation (December 2025) ## Prerequisites You'll need these things: - Claude Desktop app installed (latest version with Desktop Extensions support) - Tallyfy API key (grab it from your organization settings) - For manual setup: Node.js version 18 or higher and basic comfort with editing JSON files - For simplified setup: Just click install on any .mcpb file - zero configuration, automatic updates, dependency management included ## MCP ecosystem The MCP ecosystem has grown significantly with major platform adoption: ### Official MCP servers available - **GitHub**: Repository management, issue tracking, PR workflows - **Stripe**: Payment processing with natural language monetization - **PayPal**: Commerce capabilities including inventory, payments, shipping, refunds - **Slack**: Team communication with Real-time Search API - **Linear**: Project management with OAuth-authenticated remote MCP - **Sentry**: Error tracking with direct IDE integration - **PostgreSQL, MySQL, MongoDB**: Database operations with schema inspection - **Filesystem**: Local file operations with sandboxed access controls - **Brave Search**: Privacy-focused web research - **Atlassian**: Jira and Confluence integration via Remote MCP Server - **ServiceNow**: Enterprise workflow automation - **Apollo**: GraphQL API management ### MCP directories and marketplaces - **PulseMCP (pulsemcp.com)**: Large directory updated regularly - **mcpservers.org**: Community-driven collection synced with GitHub repositories - **MCP Market (mcpmarket.com)**: Connect Claude and Cursor to Figma, Databricks, Storybook - **cursor.directory/mcp**: Cursor-specific optimized servers - **mcp.so**: Official Anthropic community platform with server registry ## Setting up Tallyfy MCP Server with Claude Desktop ## Practical demonstrations ### Example 1: Task management workflow **User prompt:** ``` Find all tasks assigned to me that are due this week and create a summary report. ``` **Claude with MCP will:** 1. Use the `search_tasks` tool to query Tallyfy 2. Filter results for current user and date range 3. Format findings into a structured report 4. Optionally save the report locally using filesystem MCP ### Example 2: Process automation **User prompt:** ``` Check if there are any stalled processes in our "Customer Onboarding" template and suggest next actions. ``` **Claude with MCP will:** 1. Query for active processes using the template 2. Identify tasks that haven't progressed recently 3. Analyze blockers based on task data 4. Provide specific recommendations ### Example 3: Bulk operations **User prompt:** ``` Reassign all of John's open tasks to Sarah due to his vacation. ``` **Claude with MCP will:** 1. Search for all tasks assigned to John 2. Filter for open status 3. Execute bulk reassignment to Sarah 4. Provide a summary of changes made ## Unique Claude Desktop features ### 1. Projects for persistent context Claude Desktop's **Projects** feature is a game-changer for workflow management. Create a project for each major workflow or client, and Claude remembers everything. Upload process docs once, reference them forever. Your task history stays put between sessions. It's perfect when you're managing ongoing processes that span weeks or months. Projects benefit from enhanced memory capabilities - Claude can extract and save key facts to maintain continuity and build tacit knowledge over time. The extended thinking feature lets Claude work on complex problems, alternating between reasoning and tool use. ### 2. Local file system integration Web-based AI tools can't touch your local files. Claude Desktop can: ```json { "mcpServers": { "filesystem": { "command": "npx", "args": [ "-y", "@modelcontextprotocol/server-filesystem", "/Users/username/Documents/Tallyfy" ] } } } ``` What can you do with this? Plenty: - Read process documentation straight from your hard drive - Export Tallyfy data to CSV files (hello, Excel reports) - Sync local templates with Tallyfy in seconds ### 3. Tool composition Claude Desktop really shines when you connect multiple MCP servers. Watch this: **Real workflow we built last week:** 1. Filesystem MCP reads a CSV of 50 new employees 2. Tallyfy MCP creates onboarding processes for each one 3. Slack MCP pings the HR team with status updates 4. GitHub MCP automatically creates IT access tickets ### 4. Developer-friendly interface Developers, you're in for a treat: - MCP server logs live in `~/Library/Logs/Claude/` (macOS) or `%APPDATA%\Claude\logs\` (Windows) - Watch tool calls happen in real-time with built-in debugging - Test your custom MCP servers without breaking production - Claude Code integration: Native extensions for VS Code and JetBrains IDEs with inline diff viewing - Remote MCP servers: Hosted on Cloudflare with OAuth, no local setup needed - GitHub Actions support: Background tasks and CI/CD workflows ## Limitations in Claude Desktop Let's be honest about what Claude Desktop can't do: ### 1. Visual interface constraints **The problem**: Claude Desktop lives in text. No pretty pictures. **What you lose:** - Can't see Tallyfy's visual process tracker - No clickable flowcharts or diagrams - Progress bars? You get "75% complete" in plain text **Fix it**: Have Claude generate the data, then visualize it in Tallyfy's web interface. ### 2. Real-time updates **The problem**: MCP works like email, not instant messaging. **What's missing:** - No live alerts when tasks change - You have to ask Claude to check for updates - Can't watch processes update in real-time **Fix it**: Schedule periodic checks or set up webhooks for the urgent stuff. ### 3. Complex form interactions **The problem**: Fancy forms become plain text nightmares. **Real examples that hurt:** - Multi-select dropdown with 50 options? You're listing them all - Need to upload a file? That's a separate workflow - Date picker? Type the date manually and hope you get the format right ### 4. Authentication scope **The problem**: One API key = one identity. **The reality check:** - Everything happens as the API key owner - Can't switch between user accounts - Your audit trail shows one person doing everything (spoiler: it's you) ## Ideal use cases for Claude Desktop + Tallyfy MCP ### 1. Morning workflow review **Strength**: Quick status checks and prioritization. **Example routine:** ``` "Good morning! Show me all tasks due today, any overdue items, and processes that need my attention. Create a prioritized action list." ``` In 30 seconds, you've got your entire day mapped out. ### 2. Process analysis and optimization **Strength**: Deep analysis of workflow patterns. **Example:** ``` "Analyze the last 50 completed 'Customer Onboarding' processes. Identify the steps with longest completion times and suggest optimizations." ``` Claude spots the bottlenecks you've been missing for months. ### 3. Documentation generation **Strength**: Creating detailed process documentation. **Example:** ``` "Generate a detailed SOP document for our 'Invoice Processing' template, including all steps, responsible parties, and average completion times." ``` Your 20-page SOP document? Done in 2 minutes. ### 4. Intelligent task routing **Strength**: Complex decision-making for task assignments. **Example:** ``` "Review the skills and current workload of team members, then suggest optimal task assignments for the next week's projects." ``` No more playing favorites - Claude assigns work based on actual capacity and skills. ### 5. Compliance reporting **Strength**: Generating audit-ready reports. **Example:** ``` "Create a compliance report showing all 'Data Access Request' processes from last quarter, including completion times and any SLA violations." ``` Auditor coming tomorrow? Your compliance report is ready today. ## Combining Claude MCP with Claude Computer Use Here's where things get interesting. Combine Claude's text-based MCP with [Claude Computer Use](/products/pro/integrations/computer-ai-agents/vendors/claude-computer-use/), and you've got automation superpowers: ### Complementary capabilities **Claude MCP excels at:** - Querying and analyzing Tallyfy data via API - Bulk operations across multiple records - Generating reports and insights - Making data-driven decisions **Claude Computer Use excels at:** - Interacting with visual interfaces - Filling forms in third-party applications - Navigating complex UI workflows - Handling applications without APIs ### Example hybrid workflow **Scenario**: Monthly compliance reporting requiring both data analysis and visual form submission. **Step 1: Claude MCP** (API-based data gathering) ``` "Analyze all completed audit processes this month, identify any non-compliance issues, and prepare a summary report with statistics. Export to CSV for backup." ``` **Step 2: Claude Computer Use** (Visual UI automation) ``` "Open the government compliance portal in Chrome, navigate to the monthly report section, and fill in the form with the statistics from the CSV file. Take screenshots of each step for audit trail." ``` Teams report significant time savings using this hybrid approach compared to manual processes. ### Best practices for hybrid automation 1. **Use MCP for data operations**: Use API access for efficient data retrieval and processing 2. **Use Computer Use for UI-only tasks**: Reserve visual automation for applications without API access 3. **Pass data between modes**: Use files or clipboard to transfer data between MCP and Computer Use sessions 4. **Monitor costs**: Computer Use with screenshots is more expensive than MCP API calls 5. **Design for reliability**: MCP operations are more deterministic than visual UI automation ### Implementation considerations When designing workflows that use both capabilities: - Start with MCP for data gathering and preparation - Switch to Computer Use only when visual interaction is required - Return to MCP for final data validation and storage - Document which parts of the workflow use which capability - Test failure points and implement appropriate fallbacks Mix these approaches right, and you can automate workflows that seemed impossible previously. ## Security considerations Don't skip this part - security matters: 1. **Local configuration security** - Desktop Extensions automatically encrypt sensitive values using OS secure storage (Keychain on macOS, Credential Manager on Windows) - Mark fields as `"sensitive": true` in manifest.json for automatic encryption - Store API keys in environment variables, never in plaintext JSON - Restrict file permissions: `chmod 600 claude_desktop_config.json` on macOS/Linux - Use separate API keys for dev/staging/production environments 2. **MCP server isolation** - Run MCP servers with minimal permissions using sandboxed Node.js runtime - Remote MCP servers use OAuth 2.1 authentication with PKCE - Tallyfy supports these endpoints: - Authorization: `https://go.tallyfy.com/mcp/oauth/authorize` - Token: `https://go.tallyfy.com/mcp/oauth/token` - DCR: `https://go.tallyfy.com/mcp/oauth/register` - Available scopes: `mcp:tasks`, `mcp:processes`, `mcp:templates`, `mcp:users`, `mcp:read`, `mcp:write` - Implement request validation and input sanitization in your server code - Log all API calls with timestamps for audit compliance - Desktop Extensions include signature verification to prevent tampering 3. **Data handling** - Be cautious about sensitive data - Claude Desktop stores conversation history locally in `~/Library/Application Support/Claude/` - Projects feature maintains persistent context - review what you're sharing - Web search capability can expose queries - disable for sensitive work - Consider GDPR/CCPA compliance for EU/California users - Use prompt caching but remember cached data persists 4. **Network security** - Use HTTPS for all API communications with TLS 1.3 minimum - Monitor for unusual patterns - Claude logs rate limit hits - Remote MCP servers eliminate local attack surface but require internet connectivity - Implement exponential backoff: 30s → 1min → 5min → 15min for retries ## Advanced configuration ### Running multiple MCP servers Claude Desktop supports multiple simultaneous MCP connections. With Desktop Extensions, you can install many servers with one-click, or configure manually: ```json { "mcpServers": { "tallyfy": { "command": "node", "args": ["~/tallyfy-mcp-server/server.js"], "env": { "TALLYFY_API_KEY": "key-1" } }, "filesystem": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "~/Documents"] }, "github": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-github"], "env": { "GITHUB_TOKEN": "ghp_xxx" } }, "stripe": { "command": "npx", "args": ["-y", "@stripe/mcp-server"], "env": { "STRIPE_API_KEY": "sk_xxx" } } } } ``` Popular MCP servers include GitHub, Stripe, PayPal, Slack, Linear, Sentry, Asana, Atlassian Jira, Block, Intercom, and thousands more through community repositories. Leading integration platforms like Boomi, MuleSoft Anypoint, and Zapier support MCP standards. ### Custom server development tips 1. **Use TypeScript for better type safety** ```typescript import { Server } from '@modelcontextprotocol/sdk/server/index.js'; import { TallyfyClient } from './tallyfy-client'; ``` 2. **Implement thorough error handling** ```javascript try { const result = await tallyfyApi.call(); return { content: [{ type: 'text', text: result }] }; } catch (error) { return { error: { code: 'TALLYFY_API_ERROR', message: error.message } }; } ``` 3. **Add request logging for debugging** ```javascript console.error(`[Tallyfy MCP] ${new Date().toISOString()} - ${request.method}`); ``` ## Known issues and workarounds 1. **Windows paths need escaping**: Use forward slashes `/` or double backslashes `\\` in JSON configs 2. **Data limits exist**: Paginate when pulling 1000+ items - Claude truncates large responses 3. **Connections drop after extended idle**: Implement heartbeat or retry logic with exponential backoff 4. **Memory usage grows**: Restart Claude Desktop periodically during heavy use 5. **Rate limits apply**: Track your usage - limits vary by plan tier 6. **SSE transport deprecated**: Use Streamable HTTP instead of Server-Sent Events for new integrations - SSE is being phased out across the industry 7. **OAuth token refresh**: Some users reported OAuth issues after the December 2025 Claude updates - if you experience authentication failures, try re-authorizing or use API key authentication as a workaround 8. **Remote MCP requires internet**: Unlike local stdio servers, remote MCP servers on Cloudflare require active internet connection ## Claude vs ChatGPT for MCP ### Current status comparison **Claude Desktop**: - Full MCP support with mature implementation - Desktop Extensions (.mcpb) for one-click installation - Remote MCP servers with OAuth on Cloudflare - Claude Opus 4.5: Flagship model with exceptional coding performance - Extended thinking with tool use during reasoning **ChatGPT/OpenAI**: - MCP in Agents SDK with Responses API support - Desktop app MCP support for Team/Enterprise with custom connectors - GPT models with strong reasoning capabilities - Competitive API pricing with prompt caching discounts - Custom connectors (MCP) for Team/Enterprise/Edu plans with admin controls ### Key differentiators **Choose Claude for MCP if you need**: - Most mature MCP implementation - Desktop Extensions for zero-config installation - Projects feature for persistent context across sessions - Computer Use capability for hybrid API + visual automation - Strong coding performance - IDE integrations (VS Code, JetBrains) with inline editing **Consider ChatGPT if you need**: - Strong reasoning capabilities - Deep Microsoft ecosystem integration (Teams, Office, Azure) - Large user community and ecosystem - Custom MCP connectors for enterprise (admin-controlled) ## Best practices 1. **Start simple**: Begin with read-only operations before implementing modifications 2. **Test thoroughly**: Use a Tallyfy sandbox environment during development - never test in production 3. **Document your tools**: Provide clear descriptions and `inputSchema` for each MCP tool 4. **Version your servers**: Include semantic versioning (e.g., 1.2.3) in manifest.json 5. **Monitor usage**: Track API calls closely - Claude enforces usage limits 6. **Use Desktop Extensions**: Package your server as .mcpb for easy distribution and updates 7. **Implement caching**: Use prompt caching for repetitive queries 8. **Handle errors gracefully**: Return proper MCP error codes, not raw exceptions ## Future outlook The MCP ecosystem has reached industry-standard status: - **Agentic AI Foundation**: In December 2025, Anthropic donated MCP to the Linux Foundation - co-founded by Anthropic, Block, and OpenAI, with AWS, Google, Microsoft, Cloudflare, and Bloomberg as supporting members - **Desktop Extensions**: Install MCP servers like browser extensions with .mcpb packages - zero configuration needed - **Remote MCP servers**: Live on Cloudflare with OAuth 2.1, eliminating local setup entirely - **Streamable HTTP transport**: The new standard for remote servers, replacing deprecated SSE transport - **Industry alignment**: OpenAI, Microsoft, Google, and all major AI providers support MCP, with SDKs in Python, TypeScript, C#, Java, Go - **Growing ecosystem**: Thousands of MCP servers available through community repositories and marketplaces - **Enterprise adoption**: Major companies including Stripe, PayPal, Linear, Sentry, Asana, Atlassian, Block, Apollo, and UiPath have launched production servers - **Low-code integration**: Platforms like Mendix, OutSystems, and Microsoft Power Platform embrace MCP standards ## Conclusion Claude Desktop + Tallyfy MCP has matured significantly. With Desktop Extensions eliminating setup complexity, Claude's strong coding capabilities, and the growing MCP ecosystem with all major tech companies on board, the platform is more powerful than ever. Yes, you still won't get Tallyfy's visual process tracker or real-time updates in the text interface. But here's what changed: one-click installation via Desktop Extensions, extended thinking with tool use, and the entire industry standardizing on MCP. The math is simple. Spend seconds installing via Desktop Extensions instead of manually editing JSON. Save hours each month automating workflows. That's enough to transform how your team works. - **[Using Tallyfy MCP server with Microsoft Copilot Studio](https://tallyfy.com/products/pro/integrations/mcp-server/microsoft-copilot-studio/)**: Microsoft Copilot Studio provides enterprise-grade MCP integration with Tallyfy through Azure Functions and Power Platform custom connectors enabling multi-agent orchestration for complex workflows like employee onboarding with features including Virtual Network isolation and Data Loss Prevention policies and deep integration with Dynamics 365 and Power BI though it requires multiple license tiers and has regional availability limitations. :::note[MCP Client Compatibility] An MCP server can be used by any MCP client that supports it. Although you can use Tallyfy's MCP server with common AI platforms like OpenAI, Claude or Microsoft Copilot Studio - the UI and ability to do useful work in real life is limited by many factors which are highlighted in this page. Tallyfy is developing its own fully-featured chat UI which will solve all the major problems of using MCP servers with mainstream text-chat AI providers. However, to start using MCP immediately - we recommend adding it to your AI subscription so that you can get the value and benefits immediately. You can additionally use the fully featured Tallyfy-specific AI interface when we launch it. ::: ## Overview Microsoft Copilot Studio brings enterprise-grade MCP support to organizations that need AI agents connected to their business systems. Connect Tallyfy's MCP server with Copilot Studio, and you'll build intelligent agents that automate workflows, manage processes, and interact with your Tallyfy data through natural language commands. Want to know how it all works? This guide walks you through configuring Tallyfy's MCP server with Microsoft Copilot Studio, tapping into unique enterprise features, working around limitations, and implementing battle-tested production practices. ## Microsoft Copilot Studio MCP support status Here's the current state of MCP support in Copilot Studio (public preview as of November 2025): - **Public preview**: MCP server support now in public preview across Copilot Studio - **Transport methods**: Streamable HTTP only (SSE is deprecated and no longer supported) - **MCP resources**: Full support for files and images in MCP responses - **Enterprise features**: Virtual Network integration, Data Loss Prevention (DLP), multiple authentication methods - **Admin visibility**: MCP-enabled agents visible in M365 admin center for governance - **Agent 365**: Unified control plane for managing AI agents across Microsoft ecosystem - **Platform integration**: Native Power Platform connector infrastructure - **Prebuilt connectors**: GitHub, Asana, Jira, Dataverse, Dynamics 365 (Sales, Finance, Supply Chain, Service), Microsoft Fabric - **MCP governance**: MCP now governed by Agentic AI Foundation under Linux Foundation (December 2025) **Note:** SSE transport is deprecated - Copilot Studio only supports Streamable HTTP for MCP. Use Streamable HTTP for all implementations. ## Prerequisites You'll need a few things in place before diving in: - Microsoft Copilot Studio license (trial or paid) - Tallyfy API key (grab it from your Tallyfy organization settings) - Power Apps or Power Automate access (for creating custom connectors) - Generative Orchestration enabled in your Copilot Studio agent - Environment in a supported region (check Microsoft documentation for current availability) ## Setting up Tallyfy MCP Server with Microsoft Copilot Studio Ready to get started? Here's how to connect everything: ## Integration flow overview This diagram shows how Tallyfy MCP Server connects with Microsoft Copilot Studio through the Power Platform infrastructure. [Diagram removed for brevity] **What to notice:** - The setup involves multiple Microsoft services (Azure, Power Apps, Copilot Studio) that must be configured in sequence - Authentication happens at the Power Apps connector level using your Tallyfy API key - DLP policies provide an additional security layer for enterprise deployments ## Multi-agent orchestration pattern See how Copilot Studio coordinates multiple specialized agents for complex workflows like employee onboarding. [Diagram removed for brevity] **What to notice:** - The Primary Agent acts as an orchestrator, delegating specific tasks to specialized agents - Each agent creates and manages its tasks through Tallyfy's API - All progress is centrally monitored through Tallyfy's tracker view for complete visibility ## Enterprise deployment architecture This shows the recommended architecture for large organizations requiring high availability and security. [Diagram removed for brevity] **What to notice:** - Multiple MCP server instances provide high availability behind a load balancer - Security is layered with WAF, DLP policies, and VNet isolation - Managed identities eliminate the need to store credentials in code ## Practical demonstrations ### Example 1: Multi-agent orchestration **Scenario**: Coordinate multiple agents for complex workflows. **User prompt:** ``` Start the employee onboarding process for Jane Smith, assign tasks to HR and IT, and schedule training sessions. ``` **Copilot Studio with MCP will:** 1. Primary agent receives the request 2. Delegates to HR agent for documentation tasks via Tallyfy 3. Delegates to IT agent for system access setup 4. Delegates to Training agent for session scheduling 5. Monitors progress across all sub-agents 6. Reports consolidated status back to you ### Example 2: Power Platform integration **Scenario**: Combine Tallyfy workflows with Microsoft tools. **User prompt:** ``` When a new sales opportunity is created in Dynamics 365, start our proposal process in Tallyfy and create a Teams channel for collaboration. ``` **Implementation:** 1. Power Automate flow triggers on Dynamics 365 opportunity 2. MCP server creates Tallyfy process instance 3. Teams connector creates dedicated channel 4. Agent monitors and reports progress ### Example 3: Enterprise compliance workflow **Scenario**: Automated compliance checking with approvals. **User prompt:** ``` Review all completed audit processes this quarter and generate a compliance report with any violations highlighted. ``` **Copilot Studio with MCP will:** 1. Query Tallyfy for audit process data 2. Analyze completion times against SLAs 3. Check for required approvals 4. Generate formatted report in SharePoint 5. Route to compliance team if violations found ## Unique Microsoft Copilot Studio features ### 1. Enterprise security and governance Here's where Copilot Studio really shines - it taps into Microsoft's entire enterprise infrastructure: - **Virtual Network (VNet) integration**: Isolate MCP traffic within your network - **Data Loss Prevention (DLP)**: Apply policies to prevent data exfiltration - **Azure AD authentication**: Use your existing identity management - **Compliance certifications**: Inherit Microsoft's compliance framework ### 2. Power Platform ecosystem You get deep integration with Microsoft's low-code platform - and that's huge: - **Power Automate flows**: Trigger complex workflows from MCP actions - **Power Apps integration**: Build custom UIs for Tallyfy data - **Dataverse storage**: Store workflow metadata in Microsoft's database - **Power BI reporting**: Create dashboards from Tallyfy analytics ### 3. Multi-agent orchestration This is where Copilot Studio really excels. It coordinates multiple agents like a pro: - Delegate tasks between specialized agents - Maintain context across agent handoffs - Central monitoring of multi-agent workflows - Built-in error handling and fallback mechanisms ### 4. Tools and prompts framework Centralized management of reusable components: - **Prompt library**: Create and share custom prompts across agents - **Tool catalog**: Browse and install prebuilt MCP connectors - **Version control**: Track changes to tools and prompts - **Testing framework**: Validate tools before deployment ## Limitations in Microsoft Copilot Studio Let's be honest - MCP with Copilot Studio isn't perfect. You'll hit some roadblocks: ### 1. Licensing complexity **Challenge**: Multiple license tiers with varying capabilities. **Limitations:** - MCP requires Generative Orchestration (extra cost - ouch) - Message limits vary by plan (25K to 200K messages/month) - Some features need Power Platform licenses too - Multi-agent orchestration still in preview for select customers ### 2. Regional availability **Challenge**: Not all features available globally. **Limitations:** - MCP available in limited regions initially - Data residency requirements may restrict usage - Preview features often US-only at launch - Compliance varies by geography ### 3. Connector development overhead **Challenge**: Creating custom connectors requires additional steps. **Limitations:** - Must create OpenAPI specifications - Power Apps/Automate knowledge needed - Testing takes longer than direct MCP - Versioning and updates require republishing ### 4. Performance considerations **Challenge**: Enterprise features add latency. **Limitations:** - DLP policy evaluation adds processing time - VNet routing increases response times (10-50ms typically) - Large result sets require pagination - Rate limits shared across Power Platform ## Ideal use cases for Copilot Studio + Tallyfy MCP Where does this combo really shine? Let me show you: ### 1. Enterprise workflow automation **Strength**: Microsoft's ecosystem handles end-to-end automation beautifully. **Example:** ``` "When a purchase order exceeds $50,000 in Dynamics 365, initiate our approval workflow in Tallyfy, notify stakeholders in Teams, and track in Power BI." ``` ### 2. Compliance and audit management **Strength**: Built-in governance and security features. **Example:** ``` "Monitor all SOX compliance processes, ensure proper segregation of duties, and generate audit reports with full trail documentation." ``` ### 3. Cross-functional process orchestration **Strength**: Multi-agent coordination capabilities. **Example:** ``` "Coordinate our product launch process across marketing, sales, and operations teams, with each department's agent handling their specific tasks." ``` ### 4. Intelligent process mining **Strength**: Analytics and AI-powered insights. **Example:** ``` "Analyze our customer service processes to identify bottlenecks, suggest optimizations, and automatically implement approved changes." ``` ### 5. Regulated industry workflows **Strength**: Enterprise compliance and security. **Example:** ``` "Manage our FDA submission process with full audit trails, approval chains, and automatic compliance checking at each step." ``` ## Security considerations You can't skip security when deploying Tallyfy MCP in Copilot Studio. Here's what matters: 1. **Network security** - Deploy MCP servers within VNet for isolation - Use Private Endpoints for Azure services - Implement Web Application Firewall (WAF) rules - Enable DDoS protection for public endpoints 2. **Authentication and authorization** - Use Azure AD for user authentication - Implement service principal authentication for server-to-server - Apply conditional access policies - Enable multi-factor authentication 3. **Data protection** - Classify data sensitivity levels - Apply DLP policies based on classification - Enable encryption at rest and in transit - Implement data retention policies 4. **Monitoring and compliance** - Enable Azure Monitor for MCP servers - Configure alerts for anomalous behavior - Regular security assessments - Maintain audit logs for compliance ## Deployment architectures ### Basic deployment (Small organizations) ``` [Copilot Studio] → [Custom Connector] → [Azure Function MCP Server] → [Tallyfy API] ``` ### Enterprise deployment (Large organizations) ``` [Copilot Studio] ↓ (VNet Integration) [API Management] ↓ (Private Endpoint) [App Service Environment] ├── [MCP Server Instance 1] ├── [MCP Server Instance 2] └── [Load Balancer] ↓ (Managed Identity) [Tallyfy API] ``` ### Hybrid deployment (Multi-cloud) ``` [Copilot Studio] → [ExpressRoute] → [On-premises MCP Server] → [Tallyfy Private Instance] ↘ ↗ [Azure MCP Server] → [Tallyfy Cloud] ``` ## Best practices Want your implementation to succeed? Follow these proven practices: 1. **Start with prebuilt connectors**: Use Microsoft's MCP connectors as templates 2. **Implement retry logic**: Handle transient failures gracefully 3. **Use managed identities**: Never store credentials in code (yes, we've all been tempted) 4. **Monitor usage**: Track message consumption against limits 5. **Plan for scale**: Design for multi-agent scenarios from day one 6. **Test extensively**: Use Copilot Studio's testing framework 7. **Document thoroughly**: Your IT teams will thank you later ## Known issues and workarounds These issues pop up regularly - here's how to handle them: 1. **SSE no longer supported**: Migrate all implementations to Streamable HTTP - SSE endpoints will not work 2. **Tool naming conflicts**: Prefix Tallyfy tools to avoid collisions with other MCP servers 3. **Large payload handling**: Implement pagination for result sets over 100 items 4. **Session timeout**: Implement keep-alive mechanisms for long-running operations 5. **Regional latency**: Deploy MCP servers in same region as Copilot Studio 6. **MCP resource rendering**: Files and images in responses may require additional handling in custom UIs 7. **Admin center visibility**: MCP-enabled agents must be properly registered to appear in M365 admin center ## Future outlook What's coming next? Microsoft's roadmap looks promising: - **General availability**: MCP support moving from public preview to GA - **Agent 365 expansion**: Unified control plane for all AI agents across Microsoft ecosystem - **Enhanced multi-agent capabilities**: More sophisticated orchestration patterns - **Improved debugging tools**: Better visibility into MCP interactions - **Expanded connector marketplace**: More prebuilt enterprise connectors (GitHub, Asana, Jira already available) - **Advanced security features**: Zero-trust architecture support with full M365 admin governance - **Performance optimizations**: Reduced latency and higher throughput - **MCP resource enhancements**: Richer file and image handling in agent responses Microsoft is a founding member of the Agentic AI Foundation, ensuring continued commitment to MCP as the industry standard for AI-tool integration. ## Conclusion Microsoft Copilot Studio's MCP implementation brings enterprise-grade capabilities to Tallyfy workflow automation. Yes, setup takes more effort than simpler alternatives. But look at what you get: - Rock-solid security and compliance features - Deep integration with Microsoft's entire ecosystem - Multi-agent orchestration that actually works - Enterprise architecture that scales Already using Microsoft tools? Copilot Studio's MCP support is your natural path to intelligent workflow automation with Tallyfy. ### Vendors - **[ADP Workforce Now](https://tallyfy.com/products/pro/integrations/vendors/adp-workforce-now/)**: ADP Workforce Now excels at HR and payroll management but lacks cross-departmental workflow orchestration capabilities which Tallyfy fills by automating complex multi-team processes like onboarding IT provisioning facilities coordination and multi-level approval routing that typically require manual intervention. ## The gap ADP Workforce Now cannot fill ADP Workforce Now provides full HR, payroll, and talent management. But the moment employee events occur, coordination across multiple departments requires manual intervention. ADP Workforce Now cannot orchestrate IT provisioning when someone is hired. It cannot coordinate Facilities for workspace setup. It cannot route complex approvals through multiple departments for compensation changes. These cross-system handoffs happen through email and manual tracking. **What ADP Workforce Now manages:** - Full payroll and tax services - HR administration and employee records - Talent management and recruiting - Benefits and time management **What falls through the cracks:** - Cross-department approval routing for compensation and role changes - IT and Facilities coordination during onboarding - Multi-stakeholder workflows spanning HR, Finance, and Legal - Real-time process visibility across the organization - Structured escalation when approvals stall ADP Workforce Now serves your HR organization. But enterprise processes require coordination across every department. Tallyfy orchestrates workflows across ALL your teams - not just one. ## How Tallyfy fills this gap When an ADP Workforce Now event fires - hire, promotion, termination - Tallyfy launches a structured workflow with clear ownership, deadlines, and escalation. ### Enterprise onboarding When ADP records a new hire, Tallyfy orchestrates: - IT equipment provisioning and system access - Facilities workspace and building access - Compliance training and certification tracking - Finance expense and corporate card setup - Security clearance and background check coordination ### Approval workflows When ADP records changes requiring approval, Tallyfy handles: - Multi-level compensation change approvals - Role change routing through HR, Finance, and Legal - Promotion workflows with budget validation - Exception handling when approvals are delayed ## Connect today **Middleware**: Connect via [Zapier](/products/pro/integrations/middleware/zapier/), [Power Automate](/products/pro/integrations/middleware/power-automate/), or [Workato](/products/pro/integrations/middleware/workato/). **API**: Build custom integration using [Tallyfy's API](/products/pro/integrations/open-api/) with ADP's REST APIs. ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss connecting ADP Workforce Now with your Tallyfy workflows. - **[Automation Anywhere](https://tallyfy.com/products/pro/integrations/vendors/automation-anywhere/)**: Tallyfy bridges the gap between Automation Anywhere's bot automation and human workflow coordination by providing end-to-end process visibility accountability and intelligent routing that connects automated tasks with manual steps. ## The gap Automation Anywhere cannot fill Automation Anywhere's cloud-native platform excels at automating repetitive digital tasks. But business processes don't end when a bot finishes - they continue with human activities that Automation Anywhere cannot coordinate. When an Automation Anywhere bot processes a purchase order, the PO still needs human approval. When it extracts data from emails, someone needs to verify exceptions. When it updates a CRM, a sales rep needs to follow up. These human steps happen outside the bot's visibility. **What Automation Anywhere automates:** - Document processing with IQ Bot - Data extraction and transformation - Cross-application workflows - Cloud and desktop automation **What falls through the cracks:** - Process visibility across automated and manual steps - Accountability for end-to-end process outcomes - Human judgment steps embedded in automated flows - SLA tracking that spans bots and people - Exception escalation to the right human reviewers - Coordination when multiple bots and humans share a process Automation Anywhere automates tasks. Tallyfy orchestrates processes - providing the visibility and accountability layer that connects bot work with human work. ## How Tallyfy fills this gap Tallyfy serves as the orchestration layer that connects Automation Anywhere with human workflows, creating complete process automation. ### End-to-end visibility When Automation Anywhere bots execute, Tallyfy provides: - Real-time status across all steps - automated and manual - Single dashboard showing bot completion and human task progress - Process-level metrics combining bot and human performance - Audit trail spanning the entire process lifecycle ### Accountability framework Tallyfy ensures nothing falls through the cracks: - Every human step has an owner and deadline - Exceptions automatically route to appropriate reviewers - Escalation rules prevent stalled processes - Completion tracking across all participants ### Intelligent routing When bots encounter edge cases, Tallyfy handles: - Classification of exception types - Routing to specialized human reviewers - Priority assignment based on business impact - Return-to-automation once resolved ## Connect today **Control Room API**: Trigger bots from Tallyfy webhooks and receive completion callbacks. **Middleware**: Connect via [Zapier](/products/pro/integrations/middleware/zapier/) or [Make](/products/pro/integrations/middleware/make/) for simpler patterns. **API**: Use [Tallyfy's API](/products/pro/integrations/open-api/) to create workflows when bots complete and trigger bots when human tasks finish. **See also**: [Combining RPA systems and human operators](/products/pro/integrations/open-api/how-does-tallyfy-combine-rpa-systems-and-human-operators/) ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss orchestrating Automation Anywhere with your Tallyfy workflows. We'll map your processes to identify where human-bot coordination adds the most value. - **[BambooHR](https://tallyfy.com/products/pro/integrations/vendors/bamboohr/)**: Connect BambooHR with Tallyfy to orchestrate cross-department workflows like onboarding, offboarding, and role changes that BambooHR cannot coordinate on its own - spanning IT, Facilities, and Finance teams. ## The gap BambooHR cannot fill BambooHR stores your employee data and handles basic HR administration. But BambooHR has an automation ceiling - it cannot coordinate the cross-department work that employee changes trigger. When someone is hired in BambooHR, the system knows their name, department, and start date. But it cannot tell IT to provision their laptop. It cannot notify Facilities to prepare their desk. It cannot schedule their orientation or set up their expense account. These handoffs happen manually - through emails, spreadsheets, and hoping someone remembers. **What BambooHR manages:** - Employee records and personal information - Time-off tracking and balances - Basic onboarding task lists - Performance review scheduling **What falls through the cracks:** - Cross-department coordination for IT, Facilities, and Finance - Multi-step approval workflows beyond basic manager sign-off - Real-time visibility into onboarding completion across teams - Conditional routing based on role, location, or department - Integration handoffs with payroll and other systems - Structured escalation when tasks are overdue BambooHR serves your HR team. But employee processes span every department. Tallyfy orchestrates workflows across ALL your teams - not just one. ## How Tallyfy fills this gap When BambooHR records an employee change - new hire, departure, promotion - Tallyfy launches a structured workflow that coordinates every downstream team. Every step has an owner, a deadline, and escalation if it stalls. ### Employee onboarding When BambooHR adds a new employee, Tallyfy orchestrates: - IT equipment provisioning and account setup - Facilities workspace and access card preparation - Training schedule based on role and department - Finance expense account and payroll setup validation - Manager introduction and team integration tasks ### Organizational changes When BambooHR records a promotion or transfer, Tallyfy coordinates: - Access permission updates across all systems - Equipment changes for new responsibilities - Training requirements for the new role - Announcement and knowledge transfer workflows ### Offboarding When BambooHR records a departure, Tallyfy ensures: - IT access revocation across all systems - Equipment return tracking - Knowledge transfer completion - Exit interview and feedback collection ## Connect today **Middleware**: Connect via [Zapier](/products/pro/integrations/middleware/zapier/), [Power Automate](/products/pro/integrations/middleware/power-automate/), or [Make](/products/pro/integrations/middleware/make/). **API**: Build custom integration using [Tallyfy's API](/products/pro/integrations/open-api/) with BambooHR's REST APIs. BambooHR uses API key authentication and supports webhooks with SHA-256 HMAC signatures. For technical implementation details including code examples and webhook handling, see [BambooHR technical integration](/products/pro/integrations/vendors/bamboohr/technical/). ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss connecting BambooHR with your Tallyfy workflows. We'll show you how to sync employee data and automate cross-department coordination. - **[Blue Prism](https://tallyfy.com/products/pro/integrations/vendors/blue-prism/)**: Tallyfy provides orchestration capabilities that bridge Blue Prism's digital workforce automation with human workflows to create unified governed processes that handle exceptions approvals and edge cases requiring human judgment. ## The gap Blue Prism cannot fill Blue Prism's enterprise-grade digital workforce handles complex automation with strong governance. But even the most sophisticated digital workers cannot handle every scenario - human judgment is still required for exceptions, approvals, and edge cases. When a Blue Prism digital worker processes loan applications, edge cases need human review. When it reconciles accounts, discrepancies require human investigation. When it processes claims, complex cases need underwriter judgment. Blue Prism orchestrates bots - not the humans who work alongside them. **What Blue Prism automates:** - Enterprise-scale digital workforce management - Complex multi-step automation sequences - Secure credential management - Governance and compliance logging for bot activities **What falls through the cracks:** - Governance over combined human-bot processes - Coordination between digital workers and human teams - Exception workflows requiring human judgment - End-to-end process accountability spanning both - Flexibility to modify human steps without code changes - SLA tracking across the entire human-bot workflow Blue Prism governs digital workers. Tallyfy provides the orchestration layer that coordinates digital workers WITH human workers in unified, governed processes. ## How Tallyfy fills this gap Tallyfy serves as the orchestration layer that connects Blue Prism with human workflows, extending governance across your entire process. ### Extended governance When Blue Prism digital workers execute, Tallyfy extends governance to: - Human activities that follow bot work - Exception handling procedures - Approval workflows triggered by bot outputs - Complete audit trails spanning bots and humans ### Bot-human coordination Tallyfy manages seamless handoffs: - Digital worker completes task → Tallyfy assigns human review - Human approves → Tallyfy triggers next digital worker - Full accountability chain maintained throughout ### Flexible exception handling When digital workers encounter exceptions: - Tallyfy receives exception notifications via webhook - Routes to appropriate human specialist based on exception type - Tracks resolution time and method - Provides data back to Blue Prism when ready to resume ## Connect today **Blue Prism API**: Trigger digital workers from Tallyfy and receive completion notifications. **Middleware**: Connect via [Workato](/products/pro/integrations/middleware/workato/) or enterprise integration platforms. **API**: Use [Tallyfy's API](/products/pro/integrations/open-api/) to orchestrate workflows that span Blue Prism digital workers and human teams. **See also**: [Combining RPA systems and human operators](/products/pro/integrations/open-api/how-does-tallyfy-combine-rpa-systems-and-human-operators/) ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss orchestrating Blue Prism with your Tallyfy workflows. We'll help you extend governance across your human-bot processes. - **[Close](https://tallyfy.com/products/pro/integrations/vendors/close/)**: Tallyfy integrates with Close CRM to orchestrate the multi-person tasks and cross-team coordination that happen between sales calls including demo scheduling with solutions engineers and pricing approvals and post-sale handoffs that Close's built-in calling and pipeline management cannot coordinate on its own. ## The gap Close cannot fill Close excels at inside sales - built-in calling, email sequences, and pipeline management for high-velocity sales teams. But between each call and each stage change, tasks must happen that Close cannot coordinate. When a sales rep logs a qualifying call in Close, the next steps often involve other people: scheduling a demo with a solutions engineer, getting pricing approved, having legal review custom terms. Close tracks the deal and the communications - but not the multi-person tasks that move deals forward. **What Close manages:** - Built-in calling and SMS - Email sequences and tracking - Pipeline and deal management - Sales team activity **What falls through the cracks:** - Micro-tasks between calls and meetings - Cross-team coordination for demos and proposals - Approval workflows for pricing exceptions - Post-call follow-up task assignment - Handoffs to Operations after close - Audit trails for deal execution Close helps reps work fast. Tallyfy ensures the supporting work across your organization happens just as fast. ## How Tallyfy fills this gap Tallyfy serves as the orchestration layer that connects Close activities with the detailed workflows that support each deal. ### Call follow-up workflows After calls logged in Close, Tallyfy: - Launches follow-up task sequences - Assigns prep work to relevant team members - Tracks completion before next touchpoint - Escalates if tasks are overdue ### Demo and proposal coordination When deals need demos or proposals, Tallyfy: - Coordinates scheduling with solutions engineers - Routes technical requirements gathering - Manages proposal development across teams - Tracks approvals and revisions ### Post-sale workflows When deals close in Close, Tallyfy orchestrates: - Immediate handoff to Customer Success - Account setup and provisioning - Onboarding kickoff tasks - Training scheduling ## Connect today **Middleware**: Connect via [Zapier](/products/pro/integrations/middleware/zapier/) to trigger Tallyfy workflows from Close events. **API**: Build custom integration using [Tallyfy's API](/products/pro/integrations/open-api/) with Close's REST API. **See also**: [Integrate to your CRM or ERP](/products/pro/integrations/middleware/integrate-into-crm/) ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss connecting Close with your Tallyfy workflows. - **[Copper](https://tallyfy.com/products/pro/integrations/vendors/copper/)**: Copper CRM captures relationship data within Google Workspace but lacks the ability to orchestrate structured cross-team task workflows and approvals that Tallyfy provides through middleware connections to coordinate deal execution across entire organizations. ## The gap Copper cannot fill Copper lives inside Google Workspace - CRM that works directly in Gmail and Google Calendar. This tight integration captures relationship data automatically. But deals require more than relationship tracking - they require coordinated tasks across teams. When a deal advances in Copper, the work that makes it advance involves multiple people: solutions architects scoping requirements, finance approving pricing, legal reviewing contracts. Copper captures emails and calendar events - but not the structured task sequences that move deals forward. **What Copper manages:** - Gmail and Calendar integration - Automatic contact and activity capture - Pipeline and deal tracking - Google Workspace native CRM **What falls through the cracks:** - Micro-tasks between each sales stage - Cross-team coordination beyond email - Structured approval workflows - Task assignment with deadlines and accountability - Post-sale handoffs with Operations - Audit trails for deal execution Copper captures what happens in Google Workspace. Tallyfy orchestrates the work that happens across your entire organization. ## How Tallyfy fills this gap Tallyfy serves as the orchestration layer that connects Copper deal changes with the detailed workflows that must happen across teams. ### Beyond email coordination When deals progress in Copper, Tallyfy: - Launches structured task workflows - Assigns work to the right people with deadlines - Tracks completion outside of email threads - Provides visibility to stakeholders ### Structured approvals When deals need approvals, Tallyfy: - Routes to the right approvers based on deal type - Handles multi-level approval chains - Documents approval history - Escalates delays automatically ### Post-sale orchestration When deals close in Copper, Tallyfy orchestrates: - Structured customer handoffs - Implementation workflows - Account provisioning tasks - Training and onboarding sequences ## Connect today **Middleware**: Connect via [Zapier](/products/pro/integrations/middleware/zapier/) or [Make](/products/pro/integrations/middleware/make/) to trigger Tallyfy workflows from Copper events. **API**: Build custom integration using [Tallyfy's API](/products/pro/integrations/open-api/) with Copper's REST API. **See also**: [Integrate to your CRM or ERP](/products/pro/integrations/middleware/integrate-into-crm/) ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss connecting Copper with your Tallyfy workflows. - **[Freshdesk](https://tallyfy.com/products/pro/integrations/vendors/freshdesk/)**: Freshdesk handles ticket management and customer communication effectively but lacks the ability to orchestrate multi-team resolution workflows and structured processes that Tallyfy provides as a coordination layer for complex support issues requiring approvals and cross-department handoffs. ## The gap Freshdesk cannot fill Freshdesk streamlines helpdesk operations with ticket management, automations, and a knowledge base. But tickets remain fundamentally unstructured - they capture conversations, not the multi-step workflows needed to resolve complex issues. When a Freshdesk ticket requires investigation by engineering, approval from management, or coordination across departments, the ticket becomes a conversation thread. Freshdesk tracks what was discussed. It doesn't orchestrate the work that needs to happen. **What Freshdesk manages:** - Ticket creation and assignment - SLA tracking and automation - Customer communication - Agent productivity metrics **What falls through the cracks:** - Multi-team resolution workflows - Approval chains for exceptions - Structured data collection at each step - Post-ticket follow-up processes - Systematic improvement workflows - Cross-department handoffs with accountability Freshdesk organizes your support queue. Tallyfy structures the work that resolves complex tickets completely. ## How Tallyfy fills this gap Tallyfy serves as the orchestration layer that connects Freshdesk tickets with the structured workflows needed for complete resolution. ### Multi-team coordination When tickets require multiple teams, Tallyfy: - Launches parallel workflows to involved departments - Assigns specific tasks with deadlines - Tracks completion across all contributors - Aggregates results back to the support team ### Exception handling When tickets need special handling, Tallyfy: - Routes approval requests to appropriate managers - Handles multi-level approval chains - Documents decision history - Enforces compliance requirements ### Systematic improvement When patterns emerge from tickets, Tallyfy orchestrates: - Root cause analysis workflows - Product bug tracking processes - Documentation improvement workflows - Training needs identification ## Connect today **Middleware**: Connect via [Zapier](/products/pro/integrations/middleware/zapier/) or [Make](/products/pro/integrations/middleware/make/) to trigger Tallyfy workflows from Freshdesk events. **API**: Build custom integration using [Tallyfy's API](/products/pro/integrations/open-api/) with Freshdesk's REST API. **See also**: [Tickets vs. Processes](/products/pro/tutorials/features/ticket-driven-vs-process-driven/) - Why structured processes beat unstructured tickets. ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss connecting Freshdesk with your Tallyfy workflows. - **[Gusto](https://tallyfy.com/products/pro/integrations/vendors/gusto/)**: Tallyfy bridges operational gaps that Gusto cannot fill by orchestrating cross-departmental workflows for employee onboarding IT provisioning training and payroll coordination while Gusto handles only HR and payroll functions. ## The gap Gusto cannot fill Gusto handles payroll, benefits, and HR for small and mid-sized businesses. But Gusto's modules require manual reconciliation, and it cannot coordinate the IT provisioning, training, and facilities setup that new hires need. When someone is hired in Gusto, the system processes their payroll and benefits. But it cannot tell IT to create their email account. It cannot schedule their orientation or set up their expense access. These coordination tasks happen in separate systems through manual handoffs. **What Gusto manages:** - Payroll processing and tax filing - Benefits administration - Time-off tracking - Basic onboarding paperwork (offer letters, e-signatures) **What falls through the cracks:** - IT provisioning and system account setup - Module synchronization requiring manual reconciliation - Timesheet exceptions and complex shift handling - Cross-department coordination for Facilities and Training - Structured workflows beyond basic onboarding checklists Gusto serves your HR and payroll needs. But employee processes span every department. Tallyfy orchestrates workflows across ALL your teams - not just one. ## How Tallyfy fills this gap When a Gusto employee event fires - hire, termination, status change - Tallyfy launches a structured workflow that coordinates every downstream team. ### Employee onboarding When Gusto records a new hire, Tallyfy orchestrates: - IT email and system account creation - Equipment provisioning based on role - Training schedule and compliance tracking - Finance expense account setup - Manager introduction workflows ### Payroll coordination When Gusto processes payroll events, Tallyfy handles: - Exception approval workflows for overtime - Expense report routing and approval chains - Benefits change validations - Multi-step approval for compensation adjustments ## Connect today **Middleware**: Connect via [Zapier](/products/pro/integrations/middleware/zapier/), [Power Automate](/products/pro/integrations/middleware/power-automate/), or [Make](/products/pro/integrations/middleware/make/). **API**: Build custom integration using [Tallyfy's API](/products/pro/integrations/open-api/) with Gusto's REST APIs. ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss connecting Gusto with your Tallyfy workflows. - **[Help Scout](https://tallyfy.com/products/pro/integrations/vendors/help-scout/)**: Tallyfy complements Help Scout by providing structured workflow orchestration and multi-team coordination for complex issues that extend beyond the conversational inbox where Help Scout excels at humanizing customer support interactions. ## The gap Help Scout cannot fill Help Scout brings humanity to support - conversations that feel like email, not tickets. This personal touch delights customers. But the conversational model shares the same structural gap as all helpdesk tools: conversations capture discussions, not workflows. When a Help Scout conversation requires product input, engineering investigation, or cross-team coordination, the thread captures what was said. Help Scout doesn't orchestrate the multi-step workflows needed to fully resolve complex issues. **What Help Scout manages:** - Email-like customer conversations - Shared inboxes with collision detection - Knowledge base (Docs) - Customer profiles and history **What falls through the cracks:** - Structured workflows from conversations - Multi-team coordination with accountability - Internal process triggers from customer needs - Post-conversation follow-up sequences - Systematic improvement workflows - Root cause analysis processes Help Scout humanizes support conversations. Tallyfy structures the work that makes customers successful beyond the inbox. ## How Tallyfy fills this gap Tallyfy serves as the orchestration layer that connects Help Scout conversations with the structured workflows that deliver complete resolution. ### Beyond the inbox When conversations need action, Tallyfy: - Launches structured task workflows - Assigns work to teams outside support - Tracks completion with deadlines - Provides visibility into resolution progress ### Team coordination When conversations involve multiple teams, Tallyfy: - Routes tasks to the right departments - Handles parallel work streams - Aggregates updates back to support - Ensures nothing falls through cracks ### Continuous improvement When patterns emerge from conversations, Tallyfy orchestrates: - Bug report workflows with engineering - Feature request evaluation processes - Documentation improvement workflows - Training and onboarding updates ## Connect today **Middleware**: Connect via [Zapier](/products/pro/integrations/middleware/zapier/) or [Make](/products/pro/integrations/middleware/make/) to trigger Tallyfy workflows from Help Scout events. **API**: Build custom integration using [Tallyfy's API](/products/pro/integrations/open-api/) with Help Scout's API. **See also**: [Tickets vs. Processes](/products/pro/tutorials/features/ticket-driven-vs-process-driven/) - Why structured processes beat unstructured conversations. ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss connecting Help Scout with your Tallyfy workflows. - **[Insperity](https://tallyfy.com/products/pro/integrations/vendors/insperity/)**: Tallyfy bridges the coordination gap that Insperity's PEO services cannot fill by orchestrating cross-departmental workflows triggered by HR events across IT facilities training and other teams beyond traditional HR administration. ## The gap Insperity cannot fill Insperity provides full-service PEO with complete HR outsourcing for SMBs. But Insperity's closed ecosystem focuses on HR administration, not coordinating the business processes that employee events trigger across your organization. When Insperity processes a new hire, they handle employment paperwork and benefits enrollment. But IT needs to create accounts. Facilities needs workspace setup. Training needs to schedule orientation. These cross-department processes require coordination beyond what a PEO provides. **What Insperity manages:** - Full-service PEO with co-employment - Payroll processing and tax filing - Benefits administration and compliance - HR consulting and risk management **What falls through the cracks:** - Cross-department coordination beyond HR - IT provisioning and system access setup - Equipment ordering and delivery tracking - Multi-stakeholder approval workflows - Real-time visibility into process completion Insperity handles your HR outsourcing. But business processes span every department. Tallyfy orchestrates workflows across ALL your teams - not just one. ## How Tallyfy fills this gap When an Insperity employee event occurs - hire, termination, status change - Tallyfy launches a structured workflow that coordinates all downstream teams outside the PEO relationship. ### Employee onboarding When Insperity records a new hire, Tallyfy orchestrates: - IT account and equipment provisioning - Facilities workspace and access setup - Training enrollment and tracking - Finance expense account configuration - Manager welcome workflows ### Offboarding coordination When Insperity processes a termination, Tallyfy ensures: - IT access revocation with proper timing - Equipment return tracking - Knowledge transfer completion - Exit process documentation ## Connect today **Middleware**: Connect via [Workato](/products/pro/integrations/middleware/workato/) (enterprise connector available). **File-Based**: Use scheduled report exports from Insperity Premier to trigger Tallyfy workflows. **API**: Build custom integration using [Tallyfy's API](/products/pro/integrations/open-api/) with file-based data exchange. ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss connecting Insperity with your Tallyfy workflows. - **[HubSpot](https://tallyfy.com/products/pro/integrations/vendors/hubspot/)**: Tallyfy complements HubSpot by orchestrating the detailed micro-tasks and cross-team coordination that occur between pipeline stage changes - handling marketing-to-sales handoffs deal execution workflows and customer onboarding sequences that HubSpot's automation cannot manage. ## The gap HubSpot cannot fill HubSpot tracks your deals through pipeline stages and unifies marketing with sales. But here's what HubSpot misses: the dozens of micro-tasks that must happen between each stage transition and during the marketing-to-sales handoff. When a marketing qualified lead becomes sales qualified in HubSpot, it looks like one status change. In reality, it requires research, discovery call scheduling, talking point preparation, and stakeholder identification. Each involves multiple people, deadlines, and conditional logic. HubSpot's workflows can automate emails - but not multi-team task coordination. **What HubSpot manages:** - Marketing automation and lead scoring - Deal pipeline and stages - Customer communications - Reporting and analytics **What falls through the cracks:** - Micro-tasks between each sales stage - Marketing-to-sales handoff coordination - Cross-team task assignment with accountability - Conditional workflows involving multiple departments - Post-sale onboarding across Operations and Success teams - Audit trails for deal execution HubSpot shows a lead became an opportunity. Tallyfy ensures every micro-task that makes that transition successful actually happens. ## How Tallyfy fills this gap Tallyfy serves as the orchestration layer that connects HubSpot pipeline changes with the detailed workflows that must happen between them. ### Marketing-to-sales handoffs When leads qualify in HubSpot, Tallyfy: - Launches structured handoff workflows - Ensures research and prep tasks complete before first call - Tracks who did what and when - Escalates if handoff tasks are delayed ### Deal execution When deals move through HubSpot stages, Tallyfy: - Coordinates proposal development across teams - Routes technical reviews based on deal requirements - Manages pricing approvals with proper sign-offs - Tracks completion across all stakeholders ### Customer onboarding When deals close in HubSpot, Tallyfy orchestrates: - Customer success handoff from Sales - Implementation kickoff workflows - Training and enablement sequences - Account provisioning tasks ## Connect today **Magic Links**: Launch Tallyfy workflows directly from HubSpot deal records with pre-filled data. **Middleware**: Connect via [Zapier](/products/pro/integrations/middleware/zapier/), [Power Automate](/products/pro/integrations/middleware/power-automate/), or [Make](/products/pro/integrations/middleware/make/). **API**: Build custom integration using [Tallyfy's API](/products/pro/integrations/open-api/) with HubSpot's APIs. **See also**: [Integrate to your CRM or ERP](/products/pro/integrations/middleware/integrate-into-crm/) ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss connecting HubSpot with your Tallyfy workflows. We'll map your sales stages to the micro-tasks that determine deal success. - **[Intercom](https://tallyfy.com/products/pro/integrations/vendors/intercom/)**: Tallyfy complements Intercom by providing structured workflow orchestration for the multi-team work and follow-up actions that happen after customer conversations end since Intercom handles chat and messaging well but cannot coordinate cross-department processes or track accountability for feature requests and customer success handoffs. ## The gap Intercom cannot fill Intercom excels at conversational support - live chat, bots, and messaging that feel natural. But conversations are inherently unstructured. They capture what customers say, not the workflows needed to act on it. When an Intercom conversation reveals a bug, requires a product change, or needs input from engineering, the chat thread captures the discussion. Intercom doesn't orchestrate the multi-team work that actually resolves the customer's underlying need. **What Intercom manages:** - Live chat and messaging - Bot-driven support automation - Customer data and segments - Conversation history and handoffs **What falls through the cracks:** - Structured workflows from conversation insights - Multi-team coordination beyond chat - Internal process triggers from customer requests - Post-conversation follow-up workflows - Feature request tracking with accountability - Customer success handoffs with clear ownership Intercom manages the conversation. Tallyfy orchestrates the work that happens after the chat ends. ## How Tallyfy fills this gap Tallyfy serves as the orchestration layer that connects Intercom conversations with the structured workflows that deliver on customer needs. ### From conversation to action When chats require follow-up, Tallyfy: - Launches structured task workflows - Assigns work to the right teams - Tracks completion with deadlines - Provides status updates back to support ### Customer success workflows When conversations identify opportunities, Tallyfy: - Triggers onboarding check-in processes - Coordinates feature adoption campaigns - Routes expansion opportunities to sales - Tracks customer health actions ### Product feedback loops When conversations surface feature requests, Tallyfy orchestrates: - Structured feature request intake - Product team evaluation workflows - Customer communication on decisions - Beta program coordination ## Connect today **Middleware**: Connect via [Zapier](/products/pro/integrations/middleware/zapier/) or [Make](/products/pro/integrations/middleware/make/) to trigger Tallyfy workflows from Intercom events. **API**: Build custom integration using [Tallyfy's API](/products/pro/integrations/open-api/) with Intercom's REST API. **See also**: [Tickets vs. Processes](/products/pro/tutorials/features/ticket-driven-vs-process-driven/) - Why structured processes beat unstructured conversations. ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss connecting Intercom with your Tallyfy workflows. - **[ADP Run](https://tallyfy.com/products/pro/integrations/vendors/adp-run/)**: ADP Run handles payroll and basic HR but lacks cross-departmental coordination capabilities which Tallyfy fills by orchestrating structured workflows across all teams when employee events occur in ADP Run. ## The gap ADP Run cannot fill ADP Run handles payroll processing and basic HR for small businesses. But the moment someone is hired in ADP, a cascade of manual coordination begins across systems that don't talk to each other. ADP Run cannot tell IT to set up email accounts. It cannot notify Facilities to prepare a workspace. It cannot trigger training enrollment or expense account setup. Teams must manually coordinate these handoffs between separate portals and systems. **What ADP Run manages:** - Payroll processing and tax filing - Basic employee records - Time and attendance tracking - Benefits administration **What falls through the cracks:** - Cross-department coordination between HR, IT, and Finance - Portal-switching friction between disconnected systems - Multi-step approval workflows spanning teams - Real-time visibility into onboarding completion - Structured handoffs with clear ownership and deadlines ADP Run serves your HR and payroll needs. But employee processes span every department. Tallyfy orchestrates workflows across ALL your teams - not just one. ## How Tallyfy fills this gap When an ADP Run employee event fires - hire, termination, role change - Tallyfy launches a structured workflow that coordinates every downstream action across your organization. ### Employee onboarding When ADP Run records a new hire, Tallyfy orchestrates: - IT account setup and equipment provisioning - Facilities workspace and access preparation - Training schedule and compliance tracking - Finance expense account configuration ### Offboarding When ADP Run records a termination, Tallyfy ensures: - IT access revocation on the correct date - Equipment return tracking - Final payroll coordination ## Connect today **Middleware**: Connect via [Zapier](/products/pro/integrations/middleware/zapier/), [Power Automate](/products/pro/integrations/middleware/power-automate/), or [Make](/products/pro/integrations/middleware/make/). **HR Integration Platforms**: Finch and Flexspring offer pre-built ADP Run connectors. **API**: Build custom integration using [Tallyfy's API](/products/pro/integrations/open-api/) with ADP's API Central. ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss connecting ADP Run with your Tallyfy workflows. - **[Kofax](https://tallyfy.com/products/pro/integrations/vendors/kofax/)**: Tallyfy bridges the workflow orchestration gap that Kofax document processing creates by managing human review approval chains and cross-department coordination that occur after document capture and data extraction. ## The gap Kofax cannot fill Kofax excels at intelligent document capture and process automation - extracting data from invoices, forms, and documents with high accuracy. But documents don't exist in isolation. They're part of broader business processes that require human review, approval chains, and cross-department coordination. When Kofax extracts invoice data, who approves payment? When it captures a contract, who reviews the terms? When it processes an application, who makes the final decision? Kofax handles document capture and data extraction - the human workflows that surround those documents need separate coordination. **What Kofax automates:** - Intelligent document capture and OCR - Data extraction from structured and unstructured documents - Document classification and routing - RPA for document-heavy processes **What falls through the cracks:** - Workflow coordination after document capture - Human review and approval chains - Exception handling for low-confidence extractions - Cross-department routing based on document content - SLA tracking for the full document lifecycle - Accountability for document processing outcomes Kofax captures and extracts. Tallyfy orchestrates - coordinating the human activities, approvals, and follow-up actions that transform captured documents into completed business processes. ## How Tallyfy fills this gap Tallyfy serves as the orchestration layer that connects Kofax document processing with human workflows. ### Document workflow orchestration When Kofax processes documents, Tallyfy: - Receives extracted data and confidence scores - Routes low-confidence extractions to human reviewers - Triggers approval workflows based on document type and content - Tracks the document through its full lifecycle ### Human review integration Tallyfy manages document review: - Kofax flags extraction for review → Tallyfy assigns to specialist - Reviewer corrects or approves → Tallyfy triggers next steps - High-confidence extractions skip review → proceed automatically - Complete audit trail of all decisions ### Post-capture workflows After Kofax extracts document data, Tallyfy orchestrates: - Multi-level approval chains - Cross-department notifications and tasks - Integration with downstream systems - Archive and retention workflows ## Connect today **Kofax TotalAgility**: Use TotalAgility activities to call Tallyfy API and receive workflow triggers. **Middleware**: Connect via [Zapier](/products/pro/integrations/middleware/zapier/) or enterprise integration platforms. **API**: Use [Tallyfy's API](/products/pro/integrations/open-api/) to trigger workflows when Kofax completes document processing. **See also**: [Combining RPA systems and human operators](/products/pro/integrations/open-api/how-does-tallyfy-combine-rpa-systems-and-human-operators/) ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss orchestrating Kofax with your Tallyfy workflows. We'll help you coordinate document capture with human review and approval processes. - **[Loom](https://tallyfy.com/products/pro/integrations/vendors/loom/)**: Loom excels at video communication but lacks process coordination features like accountability tracking and task management which Tallyfy addresses by converting video content into structured workflows with deadlines and completion verification. ## The gap Loom cannot fill Loom revolutionized async video communication. But videos are conversations - not processes. Watching a video does not ensure action happened. When someone records a training video in Loom, it gets watched (maybe). But who confirmed understanding? What tasks resulted? When someone shares feedback via Loom, does the recipient have a deadline? Is there accountability for action? These process coordination gaps exist between video communication and actual execution. **What Loom manages:** - Video recording and sharing - View tracking and analytics - Comments and reactions - Video organization and libraries **What falls through the cracks:** - Acknowledgment with accountability - Task extraction from video content - Deadline enforcement for responses - Multi-step workflows triggered by videos - Compliance documentation for training completion Loom enables video communication. But communication alone does not drive action. Tallyfy turns video content into trackable workflows with clear ownership. ## How Tallyfy fills this gap When a Loom video is shared - for training, feedback, or updates - Tallyfy launches a structured workflow that ensures communication leads to completion. ### Training workflows When training videos are shared, Tallyfy orchestrates: - Acknowledgment tracking with deadlines - Comprehension verification steps - Follow-up task assignment - Compliance documentation ### Feedback workflows When feedback videos are shared, Tallyfy handles: - Response deadline enforcement - Action item extraction and assignment - Revision tracking and approval - Completion confirmation ## Connect today **Middleware**: Connect via [Zapier](/products/pro/integrations/middleware/zapier/) or [Make](/products/pro/integrations/middleware/make/) to trigger workflows when Loom videos are recorded. **Link Detection**: Configure Slack or email integrations to detect Loom URLs and trigger appropriate workflows. **API**: Build custom integration using [Tallyfy's API](/products/pro/integrations/open-api/) with Loom SDK for embedded recording. ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss connecting Loom with your Tallyfy workflows. - **[Justworks](https://tallyfy.com/products/pro/integrations/vendors/justworks/)**: Tallyfy complements Justworks PEO services by orchestrating cross-department workflows for employee events like onboarding and offboarding that require coordination across IT facilities training and finance teams beyond what HR and payroll platforms can manage alone. ## The gap Justworks cannot fill Justworks provides PEO services with payroll, benefits, and compliance for growing companies. But the moment employee events occur, coordination across departments beyond HR requires manual intervention. When Justworks processes a new hire, they handle employment paperwork and benefits. But IT needs to provision accounts. Facilities needs to prepare workspace. Training needs to schedule onboarding. Finance needs expense access setup. These cross-department handoffs happen outside Justworks. **What Justworks manages:** - PEO services with payroll processing - Benefits administration and compliance - HR support and employee records - Time-off tracking and management **What falls through the cracks:** - Cross-department coordination beyond HR - IT provisioning and system access setup - Equipment ordering and delivery tracking - Multi-step approval workflows - Real-time visibility into onboarding completion Justworks handles your HR and payroll needs. But employee processes span every department. Tallyfy orchestrates workflows across ALL your teams - not just one. ## How Tallyfy fills this gap When a Justworks employee event fires - hire, termination, role change - Tallyfy launches a structured workflow that coordinates every downstream team outside the PEO platform. ### Employee onboarding When Justworks records a new hire, Tallyfy orchestrates: - IT account setup and equipment provisioning - Facilities workspace and access preparation - Training schedule and compliance tracking - Finance expense account configuration - Team introduction workflows ### Offboarding coordination When Justworks processes a termination, Tallyfy ensures: - IT access revocation on correct date - Equipment return tracking - Knowledge transfer workflows - Final process documentation ## Connect today **Middleware**: Connect via [Zapier](/products/pro/integrations/middleware/zapier/), [Make](/products/pro/integrations/middleware/make/), or [Workato](/products/pro/integrations/middleware/workato/). **HR Integration Platforms**: Merge and Finch offer unified API access including Justworks. **API**: Build custom integration using [Tallyfy's API](/products/pro/integrations/open-api/) with Justworks Partner API. ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss connecting Justworks with your Tallyfy workflows. - **[Namely](https://tallyfy.com/products/pro/integrations/vendors/namely/)**: Tallyfy bridges the gap in Namely's HR system by orchestrating cross-department workflows that coordinate IT provisioning facilities preparation training schedules and multi-stakeholder processes when employee events like hiring role changes or departures occur. ## The gap Namely cannot fill Namely provides all-in-one HR for mid-market companies - HRIS, payroll, benefits, and talent management. But the moment HR events trigger cross-department coordination, manual intervention is required. When Namely records a new hire, the HR system handles paperwork. But IT needs to provision accounts and equipment. Facilities needs workspace preparation. Training needs to schedule orientation. These cross-department processes require coordination beyond what Namely provides. **What Namely manages:** - HRIS and employee records - Payroll and benefits administration - Talent management and reviews - Time-off tracking and approvals **What falls through the cracks:** - Cross-department process coordination - IT provisioning and access management - Equipment ordering and tracking - Multi-stakeholder approval chains - External vendor and contractor workflows Namely serves your mid-market HR needs. But employee processes span every department. Tallyfy orchestrates workflows across ALL your teams - not just one. ## How Tallyfy fills this gap When a Namely employee event fires - hire, role change, time-off request, departure - Tallyfy launches a structured workflow that coordinates every downstream team. ### Employee onboarding When Namely records a new hire, Tallyfy orchestrates: - IT account setup and equipment provisioning - Facilities workspace and building access - Training schedule and compliance tracking - Finance expense account configuration - Team introduction workflows ### Role change coordination When Namely records a promotion or transfer, Tallyfy handles: - Access permission updates across systems - Equipment changes if needed - Training for new responsibilities - Announcement and notification workflows ## Connect today **Middleware**: Connect via [Zapier](/products/pro/integrations/middleware/zapier/), [Make](/products/pro/integrations/middleware/make/), or [Workato](/products/pro/integrations/middleware/workato/). **HR Integration Platforms**: Merge, Finch, and Apideck offer unified API access including Namely. **API**: Build custom integration using [Tallyfy's API](/products/pro/integrations/open-api/) with Namely's REST APIs. ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss connecting Namely with your Tallyfy workflows. - **[NetSuite](https://tallyfy.com/products/pro/integrations/vendors/netsuite/)**: Tallyfy bridges NetSuite's limitations by orchestrating multi-stakeholder approval chains and cross-department coordination for processes like invoice approvals and month-end close that NetSuite's single-record workflows cannot handle on their own. ## The gap NetSuite cannot fill NetSuite is your financial system of record. But NetSuite workflows operate on single records - they cannot coordinate an invoice approval that spans Accounts Payable, the department manager, and the CFO in sequence. Each approval must be a separate workflow. NetSuite records transactions. It does not orchestrate the human decisions around them. Who reviews the expense? Who approves the PO? Who verifies vendor compliance before the first payment? These coordination activities happen outside NetSuite - in email threads, spreadsheets, and meetings. **What NetSuite manages:** - Financial transactions and GL entries - Employee records via SuitePeople - Inventory and order management - Multi-subsidiary consolidation **What falls through the cracks:** - Multi-stakeholder approval chains that span departments - Month-end close coordination across Accounting, Operations, and Compliance - Vendor onboarding with legal review, risk assessment, and payment setup - Exception handling when invoices don't match POs - Cross-department budget approval workflows - Audit preparation and compliance documentation NetSuite serves your Finance team. But financial processes require coordination across Sales, Operations, Legal, and Compliance. Tallyfy orchestrates workflows across ALL your teams - not just one. ## How Tallyfy fills this gap When a NetSuite event fires - new employee, expense submitted, PO created - Tallyfy launches a structured workflow that coordinates every stakeholder. Every approval has an owner, a deadline, and escalation if someone doesn't respond. ### Invoice approvals When NetSuite receives an invoice, Tallyfy orchestrates: - Three-way match validation (PO, receipt, invoice) - Department manager approval for their cost center - Finance review for GL coding and policy compliance - CFO approval for amounts above threshold - Exception routing when matches fail ### Month-end close When period close begins, Tallyfy coordinates: - Reconciliation task assignment across teams - Journal entry review and approval chain - Accrual posting verification - Consolidation checklist completion - Compliance sign-off before close ### Vendor onboarding When Procurement requests a new vendor, Tallyfy orchestrates: - Risk assessment and compliance verification - Legal contract review and approval - Tax documentation collection (W-9, etc.) - Banking information validation - NetSuite master data creation approval ## Connect today **Middleware**: Connect via [Zapier](/products/pro/integrations/middleware/zapier/), [Power Automate](/products/pro/integrations/middleware/power-automate/), or [Make](/products/pro/integrations/middleware/make/). **iPaaS Partners**: [Celigo](/products/pro/integrations/middleware/celigo/) and [Workato](/products/pro/integrations/middleware/workato/) have native NetSuite connectors optimized for ERP integration. **API**: Build custom integration using [Tallyfy's API](/products/pro/integrations/open-api/) with NetSuite's REST APIs or SuiteScript. For technical implementation details including code examples and SuiteScript samples, see [NetSuite technical integration](/products/pro/integrations/vendors/netsuite/technical/). ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss connecting NetSuite with your Tallyfy workflows. We'll map your approval chains and identify processes that need cross-department coordination. - **[HiBob](https://tallyfy.com/products/pro/integrations/vendors/hibob/)**: Tallyfy bridges the coordination gap that HiBob cannot fill by orchestrating cross-department workflows when HR events occur ensuring IT provisioning facilities preparation and multi-stakeholder processes happen seamlessly beyond just HR data management. ## The gap HiBob cannot fill HiBob (Bob) excels at modern HR - beautiful interfaces, employee self-service, and smart automation within HR. But people processes extend beyond HR data management to coordination across every department. When someone joins in Bob, the HR system handles onboarding paperwork. But IT needs to provision accounts and equipment. Facilities needs to prepare workspace. Finance needs to set up expense access. These cross-department processes require coordination that Bob cannot orchestrate. **What HiBob manages:** - Modern HR interface and employee self-service - Time-off management and approvals - Performance cycles and reviews - Employee records and organizational structure **What falls through the cracks:** - Cross-department process coordination - IT provisioning and access management - Equipment ordering and delivery tracking - Multi-stakeholder approval chains - External vendor and contractor workflows HiBob serves your HR team beautifully. But employee processes span every department. Tallyfy orchestrates workflows across ALL your teams - not just one. ## How Tallyfy fills this gap When a HiBob employee event fires - hire, role change, time-off request, departure - Tallyfy launches a structured workflow that coordinates every downstream team. ### Employee onboarding When Bob records a new hire, Tallyfy orchestrates: - IT account setup and equipment provisioning - Facilities workspace and building access - Training schedule and compliance tracking - Finance expense account configuration - Team introduction and buddy assignment ### Time-off coordination When Bob approves time-off, Tallyfy handles: - Coverage arrangement workflows - Knowledge transfer for extended leave - Return-to-work preparation - Task reassignment during absence ## Connect today **Middleware**: Connect via [Zapier](/products/pro/integrations/middleware/zapier/), [Make](/products/pro/integrations/middleware/make/), or [Workato](/products/pro/integrations/middleware/workato/). **HR Integration Platforms**: Merge and Apideck offer unified API access including HiBob. **API**: Build custom integration using [Tallyfy's API](/products/pro/integrations/open-api/) with HiBob's REST APIs and webhooks. ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss connecting HiBob with your Tallyfy workflows. - **[Paychex](https://tallyfy.com/products/pro/integrations/vendors/paychex/)**: Tallyfy bridges the coordination gap that Paychex Flex cannot fill by orchestrating cross-department workflows when employee events occur enabling seamless handoffs between HR IT Facilities and other teams through structured automation rather than manual email tracking. ## The gap Paychex cannot fill Paychex Flex handles payroll processing, HR, and benefits administration. But the moment payroll runs or an employee status changes, coordination across departments requires manual intervention. Paychex cannot orchestrate IT account setup when someone is hired. It cannot coordinate Facilities for workspace preparation. It cannot route approval workflows for overtime exceptions or compensation changes. These cross-system handoffs happen through email and manual tracking. **What Paychex manages:** - Payroll processing and tax filing - HR administration and employee records - Benefits administration - Time and attendance tracking **What falls through the cracks:** - Cross-department coordination for IT, Facilities, and Training - Multi-step approval workflows for payroll exceptions - Reconciliation workflows between payroll and accounting - Real-time visibility into onboarding completion - Structured handoffs with clear ownership and deadlines Paychex serves your HR and payroll needs. But employee processes span every department. Tallyfy orchestrates workflows across ALL your teams - not just one. ## How Tallyfy fills this gap When a Paychex employee event fires - hire, termination, payroll completion - Tallyfy launches a structured workflow that coordinates every downstream action across your organization. ### Payroll coordination When Paychex processes payroll, Tallyfy handles: - Pre-payroll timesheet approval workflows - Exception routing for overtime and adjustments - Accounting reconciliation tasks - Cost center allocation verification ### Employee onboarding When Paychex records a new hire, Tallyfy orchestrates: - IT account setup and equipment provisioning - Facilities workspace preparation - Training schedule and compliance tracking - Finance expense account configuration ## Connect today **Middleware**: Connect via [Zapier](/products/pro/integrations/middleware/zapier/), [Power Automate](/products/pro/integrations/middleware/power-automate/), or [Make](/products/pro/integrations/middleware/make/). **HR Integration Platforms**: Flexspring offers pre-built Paychex Flex connectors. **API**: Build custom integration using [Tallyfy's API](/products/pro/integrations/open-api/) with Paychex's REST APIs. ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss connecting Paychex with your Tallyfy workflows. - **[Paycom](https://tallyfy.com/products/pro/integrations/vendors/paycom/)**: Tallyfy bridges the gap between Paycom's centralized HR data management and cross-department workflow coordination by orchestrating structured processes that span beyond HCM platforms when employee events occur. ## The gap Paycom cannot fill Paycom provides single-database HCM with payroll, HR, and talent management in one platform. But when employee events trigger cross-department coordination, manual processes take over. Paycom's single-database approach centralizes HR data. But IT still needs separate notifications for account provisioning. Facilities needs alerts for workspace setup. Training needs to coordinate schedules. These cross-department handoffs happen outside Paycom's walls. **What Paycom manages:** - Single-database payroll and HR - Talent acquisition and management - Time and labor management - Employee self-service **What falls through the cracks:** - Cross-department process coordination - IT provisioning beyond Paycom's ecosystem - Equipment ordering and delivery tracking - Multi-stakeholder approval chains - External vendor and contractor workflows Paycom centralizes your HR data. But business processes span every department. Tallyfy orchestrates workflows across ALL your teams - not just one. ## How Tallyfy fills this gap When a Paycom employee event occurs - hire, role change, time-off request, departure - Tallyfy launches a structured workflow that coordinates teams beyond the HCM platform. ### Employee onboarding When Paycom records a new hire, Tallyfy orchestrates: - IT account and equipment provisioning - Facilities workspace and access setup - Training enrollment beyond Paycom LMS - Finance expense account configuration - Team introduction workflows ### Payroll coordination When Paycom processes payroll events, Tallyfy handles: - Exception approval workflows - Accounting reconciliation tasks - Multi-step compensation change approvals - Audit documentation workflows ## Connect today **Middleware**: Connect via [Zapier](/products/pro/integrations/middleware/zapier/), [Power Automate](/products/pro/integrations/middleware/power-automate/), or [Make](/products/pro/integrations/middleware/make/). **API**: Build custom integration using [Tallyfy's API](/products/pro/integrations/open-api/) with Paycom's REST APIs (requires partner approval). ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss connecting Paycom with your Tallyfy workflows. - **[Paylocity](https://tallyfy.com/products/pro/integrations/vendors/paylocity/)**: Connect Paylocity with Tallyfy to orchestrate cross-department onboarding, offboarding, and compliance workflows that Paylocity cannot coordinate on its own - spanning IT, Facilities, Training, and Finance teams. ## The gap Paylocity cannot fill Paylocity manages your employee records and processes payroll. But the moment someone is hired in Paylocity, a cascade of manual coordination begins that Paylocity doesn't handle. Paylocity cannot tell IT to order a laptop. It cannot assign desk setup to Facilities. It cannot schedule orientation with Training or notify Finance to create an expense account. These handoffs happen in email threads, spreadsheets, and chat messages - if they happen at all. **What Paylocity manages:** - Employee data and personnel records - Payroll processing and tax compliance - Benefits administration and enrollment - Time tracking and attendance **What falls through the cracks:** - Cross-department coordination for onboarding and offboarding - IT equipment provisioning and system access setup - Multi-team approval chains for role changes and compensation - Real-time visibility into process completion across departments - Structured handoffs with clear ownership and deadlines - Compliance tracking across certification and training requirements Paylocity serves your HR team. But employee lifecycle processes span every department - IT, Facilities, Training, Finance, and Legal. Tallyfy orchestrates workflows across ALL your teams, not just one. ## How Tallyfy fills this gap When a Paylocity employee event fires - new hire, termination, role change - Tallyfy launches a structured workflow that coordinates every downstream action. Every step has an owner, a deadline, and escalation rules if something stalls. ### Employee onboarding When Paylocity records a new hire, Tallyfy orchestrates: - IT equipment ordering and system access provisioning - Facilities workspace setup and building access - Training schedule and compliance certification tracking - Finance expense account and corporate card setup - Manager introductions and team integration tasks ### Payroll coordination When Paylocity processes payroll events, Tallyfy handles: - Exception approval workflows for overtime and adjustments - Multi-tier commission review and sign-off chains - Garnishment processing with legal compliance checkpoints - Multi-state tax registration coordination ### Offboarding When Paylocity records a termination, Tallyfy ensures: - IT access revocation on the correct date - Equipment return tracking and verification - Knowledge transfer completion before last day - Exit interview scheduling and feedback collection ## Connect today **Middleware**: Connect via [Zapier](/products/pro/integrations/middleware/zapier/), [Power Automate](/products/pro/integrations/middleware/power-automate/), or [Make](/products/pro/integrations/middleware/make/). **HR Integration Platforms**: Flexspring, Joynd, Merge API, and Finch offer pre-built Paylocity connectors. **API**: Build custom integration using [Tallyfy's API](/products/pro/integrations/open-api/) with Paylocity's REST APIs and webhooks. For technical implementation details including code examples and webhook handling, see [Paylocity technical integration](/products/pro/integrations/vendors/paylocity/technical/). ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss connecting Paylocity with your Tallyfy workflows. We'll map your employee lifecycle processes and identify high-impact automation opportunities. - **[Pipedrive](https://tallyfy.com/products/pro/integrations/vendors/pipedrive/)**: Pipedrive tracks deal stages visually but cannot orchestrate the detailed cross-team tasks and approvals required to actually move deals forward while Tallyfy fills this gap by launching coordinated workflows for proposal development and contract execution when deals change stages in Pipedrive. ## The gap Pipedrive cannot fill Pipedrive gives sales teams a visual pipeline to track deals. But moving a deal from one stage to the next requires more than dragging a card - it requires coordinated tasks across multiple people that Pipedrive cannot orchestrate. When a deal moves to "Proposal Sent" in Pipedrive, the proposal itself needed technical input, pricing approval, and legal review. When it moves to "Negotiation," someone needs to track revision requests and approval chains. Pipedrive shows where deals are - not what must happen to move them forward. **What Pipedrive manages:** - Visual sales pipeline - Deal tracking and activities - Email integration - Sales reporting **What falls through the cracks:** - Micro-tasks required at each stage - Cross-team coordination for proposals - Approval workflows for pricing and contracts - Post-win handoffs to Operations - Deadline enforcement on internal tasks - Audit trails for deal execution Pipedrive tells you a deal is in the proposal stage. Tallyfy ensures the proposal gets created, reviewed, and approved correctly. ## How Tallyfy fills this gap Tallyfy serves as the orchestration layer that connects Pipedrive stage changes with the detailed workflows that must happen at each stage. ### Proposal coordination When deals reach proposal stage in Pipedrive, Tallyfy: - Launches proposal development workflows - Assigns technical scoping to the right engineer - Routes pricing for approval based on deal size - Tracks who contributed what and when ### Contract execution When deals move to negotiation in Pipedrive, Tallyfy: - Coordinates revision request handling - Routes contract changes through legal - Manages approval chains for exceptions - Ensures nothing falls through cracks ### Win/loss workflows When deals close in Pipedrive, Tallyfy orchestrates: - Customer onboarding handoff - Win review documentation - Or loss analysis and feedback capture - Account setup tasks ## Connect today **Middleware**: Connect via [Zapier](/products/pro/integrations/middleware/zapier/) or [Make](/products/pro/integrations/middleware/make/) to trigger Tallyfy workflows from Pipedrive deal events. **API**: Build custom integration using [Tallyfy's API](/products/pro/integrations/open-api/) with Pipedrive's REST API. **See also**: [Integrate to your CRM or ERP](/products/pro/integrations/middleware/integrate-into-crm/) ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss connecting Pipedrive with your Tallyfy workflows. - **[Rippling](https://tallyfy.com/products/pro/integrations/vendors/rippling/)**: Rippling excels at unifying HR IT and Finance operations internally but lacks the capability to orchestrate complex enterprise approval workflows and compliance processes that extend beyond its platform to external partners and multi-stakeholder coordination which Tallyfy addresses through structured workflow automation. ## The gap Rippling cannot fill Rippling unifies HR, IT, and Finance on one platform with strong internal automation. But enterprise approval hierarchies and regulatory compliance workflows require coordination that extends beyond Rippling's ecosystem. Rippling's if-then automation handles simple triggers well. But complex multi-conditional workflows - where approval routing depends on salary thresholds AND manager level AND department AND budget availability - require significant configuration. And workflows involving external vendors, contractors, or compliance partners need orchestration beyond Rippling's boundaries. **What Rippling manages:** - Unified employee database across HR, IT, and Finance - Device provisioning and app access management - Payroll and benefits administration - Internal if-then automation rules **What falls through the cracks:** - Enterprise approval hierarchies with complex conditions - Compliance audit trails for regulatory requirements (SOC 2, GDPR) - Coordination with external vendors, contractors, and partners - Multi-stakeholder workflows spanning outside Rippling's ecosystem - Change management rollouts across departments Rippling unifies your internal HR, IT, and Finance data. But business processes extend beyond Rippling to external partners and complex approval chains. Tallyfy orchestrates workflows across ALL your stakeholders - internal and external. ## How Tallyfy fills this gap When a Rippling employee event fires - hire, role change, termination - Tallyfy launches a structured workflow that coordinates stakeholders both inside and outside Rippling's platform. ### Enterprise approvals When Rippling records changes requiring complex approval, Tallyfy handles: - Multi-conditional routing (salary + level + department + budget) - Sequential approval chains with deadline enforcement - Escalation when approvers don't respond - Audit trails for compliance documentation ### Compliance workflows When regulatory processes are triggered, Tallyfy orchestrates: - Policy rollout coordination across all departments - External vendor and contractor compliance verification - Documentation collection and approval chains - Audit preparation with complete trails ### External coordination When processes extend beyond Rippling, Tallyfy manages: - Vendor onboarding with compliance checks - Contractor workflows with legal review - Partner coordination for implementations ## Connect today **Middleware**: Connect via [Zapier](/products/pro/integrations/middleware/zapier/), [Power Automate](/products/pro/integrations/middleware/power-automate/), or [Make](/products/pro/integrations/middleware/make/). **HR Integration Platforms**: Merge and Finch offer unified API access including Rippling. **API**: Build custom integration using [Tallyfy's API](/products/pro/integrations/open-api/) with Rippling's REST APIs. ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss connecting Rippling with your Tallyfy workflows. - **[Salesforce](https://tallyfy.com/products/pro/integrations/vendors/salesforce/)**: Tallyfy complements Salesforce by orchestrating the invisible micro-tasks and cross-team handoffs that occur between CRM pipeline stages through automated workflows that track detailed execution activities like technical reviews and legal approvals that Salesforce cannot manage. ## The gap Salesforce cannot fill Salesforce tracks your deals through pipeline stages - Lead, Qualified, Proposal, Negotiation, Closed Won. But here's what Salesforce misses: the dozens of micro-tasks that must happen between each stage transition. When a deal moves from "Qualified" to "Proposal" in Salesforce, it looks like one click. In reality, it's a cascade of coordinated activities: technical reviews, pricing approvals, legal checks, resource allocation, competitor analysis, and demo preparation. Each involves multiple people, deadlines, and conditional logic. Salesforce can't track any of this. **What Salesforce manages:** - Customer and contact data - Opportunity pipeline and stages - Sales activities and communications - Forecasting and reporting **What falls through the cracks:** - Micro-tasks between each sales stage - Cross-team handoffs (Sales → Legal → Finance → Operations) - Deadline enforcement on internal deal tasks - Conditional workflows based on deal size or type - Post-sale onboarding coordination - Audit trails for deal execution Two deals at the same stage in Salesforce can have completely different outcomes. The difference? Execution of the micro-tasks between stages. Tallyfy makes these invisible tasks visible, trackable, and automatic. ## How Tallyfy fills this gap Tallyfy serves as the orchestration layer that connects Salesforce stage changes with the detailed workflows that must happen between them. ### Micro-task orchestration When deals move through Salesforce stages, Tallyfy: - Launches the right workflow for each stage transition - Assigns tasks to the right people with deadlines - Routes work based on deal characteristics (size, type, region) - Tracks completion across all stakeholders ### Cross-team coordination Tallyfy handles handoffs Salesforce cannot: - Sales qualifies deal → Technical team scopes requirements - Pricing approved → Legal reviews contract terms - Deal closed → Operations begins onboarding - Complete visibility across all teams ### Post-sale workflows When deals close in Salesforce, Tallyfy orchestrates: - Customer onboarding sequences - Implementation project kickoff - Account provisioning and access setup - Training and enablement scheduling ## Connect today **Magic Links**: Launch Tallyfy workflows directly from Salesforce opportunity records with pre-filled data. Add a button to your opportunity page layout. **Middleware**: Connect via [Zapier](/products/pro/integrations/middleware/zapier/), [Power Automate](/products/pro/integrations/middleware/power-automate/), or [Make](/products/pro/integrations/middleware/make/). **API**: Build custom integration using [Tallyfy's API](/products/pro/integrations/open-api/) with Salesforce's REST APIs. **See also**: [Integrate to your CRM or ERP](/products/pro/integrations/middleware/integrate-into-crm/) ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss connecting Salesforce with your Tallyfy workflows. We'll map your sales stages to the micro-tasks that determine deal success. - **[Jira Service Management](https://tallyfy.com/products/pro/integrations/vendors/jira-service-management/)**: Tallyfy extends Jira Service Management's capabilities by orchestrating business processes and cross-department workflows with non-technical teams like HR Finance and Legal who don't use Jira through middleware connections or API integration. ## The gap Jira Service Management cannot fill Jira Service Management connects IT support with development through Jira. When tickets need engineering attention, the handoff is seamless. But many service requests require action from teams who don't use Jira - HR, Finance, Legal, Operations. When a JSM ticket triggers procurement, requires facilities work, or needs marketing involvement, you're back to email and manual tracking. JSM manages the IT-to-Dev flow. It doesn't orchestrate the broader business workflows that service requests often require. **What Jira Service Management manages:** - IT service request handling - Incident and problem management - Connection to Jira development workflows - Self-service portal and knowledge base **What falls through the cracks:** - Business process coordination outside Jira - Non-technical team task management - Cross-department handoffs with accountability - Approval workflows beyond IT - Vendor and external coordination - Operational follow-up processes JSM bridges IT and Development. Tallyfy bridges IT with the rest of your business. ## How Tallyfy fills this gap Tallyfy serves as the orchestration layer that extends Jira Service Management into business processes without requiring everyone to use Jira. ### Business team coordination When service requests need non-IT action, Tallyfy: - Triggers business workflows from JSM tickets - Assigns tasks to people outside Jira - Tracks completion with deadlines - Syncs status back to the service desk ### Approval workflows When requests need business approval, Tallyfy: - Routes to appropriate business approvers - Handles multi-level approval chains - Documents approval history - Enforces compliance requirements ### Operational handoffs When IT service delivery triggers business action, Tallyfy orchestrates: - New employee equipment and access setup - Vendor onboarding coordination - Security compliance workflows - Business continuity procedures ## Connect today **Middleware**: Connect via [Zapier](/products/pro/integrations/middleware/zapier/) or [Make](/products/pro/integrations/middleware/make/) to trigger Tallyfy workflows from JSM events. **API**: Build custom integration using [Tallyfy's API](/products/pro/integrations/open-api/) with Jira's REST API. **See also**: [Tickets vs. Processes](/products/pro/tutorials/features/ticket-driven-vs-process-driven/) - Why structured processes beat service tickets for business workflows. ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss connecting Jira Service Management with your Tallyfy workflows. - **[ServiceNow](https://tallyfy.com/products/pro/integrations/vendors/servicenow/)**: Tallyfy complements ServiceNow by orchestrating cross-department business workflows that extend beyond IT service management to non-technical teams without requiring expensive ServiceNow licenses for everyone. ## The gap ServiceNow cannot fill ServiceNow dominates enterprise ITSM - incident management, change requests, and IT service delivery. But many workflows triggered by IT events involve non-IT teams who don't live in ServiceNow. When a ServiceNow incident requires procurement action, HR involvement, or facilities coordination, you face a choice: force everyone into ServiceNow (expensive, complex) or lose visibility when work leaves IT. Neither option works well. **What ServiceNow manages:** - IT incident and problem management - Change and release management - IT asset management - IT service catalog **What falls through the cracks:** - Cross-department workflows beyond IT - Business process coordination for non-IT users - Simple workflows that don't justify ServiceNow complexity - Vendor and external party task coordination - Business approvals outside IT governance - Operational handoffs to non-technical teams ServiceNow manages IT workflows. Tallyfy orchestrates the business processes that IT events trigger across your entire organization. ## How Tallyfy fills this gap Tallyfy serves as the orchestration layer that extends ServiceNow's reach into business processes without forcing everyone into ITSM complexity. ### Cross-department coordination When IT events affect other teams, Tallyfy: - Launches business workflows triggered by ServiceNow - Assigns tasks to non-IT team members - Tracks completion without ServiceNow licenses - Reports status back to IT ### Business process management For workflows that don't fit ITSM, Tallyfy: - Handles simple processes without ServiceNow overhead - Manages business approvals and reviews - Coordinates vendor and external actions - Provides lightweight workflow for business teams ### Operational handoffs When IT work triggers business actions, Tallyfy orchestrates: - New system onboarding processes - Security incident response coordination - Business continuity procedures - Compliance documentation workflows ## Connect today **Middleware**: Connect via [Zapier](/products/pro/integrations/middleware/zapier/), [Power Automate](/products/pro/integrations/middleware/power-automate/), or [Make](/products/pro/integrations/middleware/make/) to trigger Tallyfy workflows from ServiceNow events. **API**: Build custom integration using [Tallyfy's API](/products/pro/integrations/open-api/) with ServiceNow's REST API. **See also**: [Tickets vs. Processes](/products/pro/tutorials/features/ticket-driven-vs-process-driven/) - Why structured processes beat ITSM tickets for business workflows. ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss connecting ServiceNow with your Tallyfy workflows. - **[Power Automate Desktop](https://tallyfy.com/products/pro/integrations/vendors/power-automate-desktop/)**: Tallyfy fills the orchestration gap that Power Automate Desktop leaves by coordinating desktop automation with human workflows cloud services and cross-department processes while managing exceptions and maintaining complete audit trails across hybrid automation scenarios. ## The gap Power Automate Desktop cannot fill Power Automate Desktop (PAD) brings RPA to every Windows user - automating clicks, keystrokes, and legacy application interactions. But desktop automation is just one piece of your business processes. The human activities that happen before, after, and alongside PAD flows need coordination too. When PAD enters data into a legacy system, who verifies it was entered correctly? When it extracts information from desktop applications, who reviews the output? When it hits an error, who resolves it? PAD automates desktop tasks - it cannot orchestrate the broader processes those tasks belong to. **What Power Automate Desktop automates:** - Legacy desktop application interaction - UI-based data entry and extraction - Local file and folder operations - Windows automation tasks **What falls through the cracks:** - Process orchestration spanning desktop automation and human work - Exception handling beyond the desktop flow - Visibility into where desktop automation fits in broader processes - Human approvals and reviews of automated outputs - SLA tracking across human and automated steps - Accountability for end-to-end process completion Power Automate Desktop automates what happens on desktops. Tallyfy orchestrates processes - coordinating desktop automation with human activities, cloud services, and cross-department workflows. ## How Tallyfy fills this gap Tallyfy serves as the orchestration layer that connects Power Automate Desktop with human workflows and cloud-based processes. ### Process orchestration When PAD flows execute, Tallyfy: - Triggers desktop automation at the right point in the process - Assigns human tasks before and after desktop automation - Tracks completion across all steps - cloud, desktop, and human - Routes exceptions to appropriate reviewers ### Human-automation coordination Tallyfy manages seamless transitions: - Human completes preparation task → Tallyfy triggers PAD flow - PAD flow completes → Tallyfy assigns verification task - Human approves → process continues to next stage - Complete audit trail maintained ### Exception management When PAD encounters errors: - Tallyfy receives notification via Power Automate cloud flow - Routes to human troubleshooter with context - Tracks resolution and outcome - Restarts automation when ready ## Connect today **Power Automate (cloud)**: Use [Power Automate](/products/pro/integrations/middleware/power-automate/) cloud flows to trigger PAD flows and connect to Tallyfy. **Hybrid pattern**: Cloud flow receives Tallyfy webhook → triggers PAD on local machine → sends completion back to Tallyfy. **API**: Use [Tallyfy's API](/products/pro/integrations/open-api/) with Power Automate HTTP actions. **See also**: [Combining RPA systems and human operators](/products/pro/integrations/open-api/how-does-tallyfy-combine-rpa-systems-and-human-operators/) ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss orchestrating Power Automate Desktop with your Tallyfy workflows. - **[QuickBooks Payroll](https://tallyfy.com/products/pro/integrations/vendors/quickbooks-payroll/)**: Tallyfy bridges the coordination gap that QuickBooks Payroll leaves by orchestrating cross-department workflows for payroll exceptions employee onboarding IT provisioning and accounting reconciliation that occur outside the payroll system. ## The gap QuickBooks Payroll cannot fill QuickBooks Payroll handles payroll processing and integrates with QuickBooks accounting. But every payroll event triggers downstream coordination that QuickBooks cannot orchestrate. When payroll runs, someone needs to verify timesheets before processing. Exceptions need routing through approval chains. Accounting needs reconciliation tasks. New hires need IT provisioning, equipment, and training coordination. These cross-department handoffs happen outside QuickBooks. **What QuickBooks Payroll manages:** - Payroll processing and tax filing - Direct deposit and payment distribution - Basic employee records - Integration with QuickBooks accounting **What falls through the cracks:** - Multi-step approval workflows for exceptions - Cross-department coordination for onboarding - IT provisioning and equipment setup - Reconciliation workflows with accounting review - Month-end close coordination QuickBooks Payroll processes your pay runs. But business processes span every department. Tallyfy orchestrates workflows across ALL your teams - not just one. ## How Tallyfy fills this gap When a QuickBooks Payroll event fires - pay run, new hire, exception - Tallyfy launches a structured workflow that coordinates every downstream team. ### Payroll coordination When QuickBooks processes payroll, Tallyfy handles: - Pre-payroll timesheet approval workflows - Exception routing for overtime and bonuses - Accounting reconciliation and review tasks - Cost center allocation verification ### Employee onboarding When QuickBooks records a new hire, Tallyfy orchestrates: - IT account setup and equipment provisioning - Training schedule and compliance tracking - Finance expense account configuration - Manager introduction workflows ## Connect today **Middleware**: Connect via [Zapier](/products/pro/integrations/middleware/zapier/), [Power Automate](/products/pro/integrations/middleware/power-automate/), or [Make](/products/pro/integrations/middleware/make/). **Unified APIs**: Merge, Finch, and Apideck offer unified accounting API access including QuickBooks. **API**: Build custom integration using [Tallyfy's API](/products/pro/integrations/open-api/) with QuickBooks Payroll API. ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss connecting QuickBooks Payroll with your Tallyfy workflows. - **[Square Payroll](https://tallyfy.com/products/pro/integrations/vendors/square-payroll/)**: Square Payroll handles merchant-focused payroll tasks but lacks cross-department coordination capabilities which Tallyfy addresses by orchestrating workflows across all teams when Square Payroll events occur. ## The gap Square Payroll cannot fill Square Payroll integrates tightly with Square's point-of-sale and payment ecosystem. But Square's focus on the merchant ecosystem means cross-department coordination requires manual intervention. When Square Payroll processes a new hire, they appear in the Square system. But IT needs to provision accounts beyond Square. Training needs to schedule orientation. Finance needs expense setup. These cross-department handoffs happen outside Square's ecosystem. **What Square Payroll manages:** - Payroll processing for Square merchants - Time tracking integrated with Square POS - Benefits administration for small teams - Tip calculations and distribution **What falls through the cracks:** - Cross-department coordination beyond Square - IT provisioning and system access setup - Multi-step approval workflows - Compliance documentation coordination - Training and onboarding across teams Square Payroll serves merchants within the Square ecosystem. But employee processes span every department. Tallyfy orchestrates workflows across ALL your teams - not just one. ## How Tallyfy fills this gap When a Square Payroll event fires - hire, termination, payroll completion - Tallyfy launches a structured workflow that coordinates teams beyond the Square ecosystem. ### Employee onboarding When Square records a new hire, Tallyfy orchestrates: - IT account setup and equipment provisioning - Training schedule and compliance tracking - Finance expense account configuration - Team introduction workflows ### Shift and labor coordination When Square tracks labor events, Tallyfy handles: - Overtime approval workflows - Compliance verification for breaks and hours - Multi-location staffing coordination - Exception routing to managers ## Connect today **Middleware**: Connect via [Zapier](/products/pro/integrations/middleware/zapier/), [Make](/products/pro/integrations/middleware/make/), or [Power Automate](/products/pro/integrations/middleware/power-automate/). **Unified APIs**: Merge and Finch offer unified API access including Square Payroll. **API**: Build custom integration using [Tallyfy's API](/products/pro/integrations/open-api/) with Square's Team and Labor APIs. ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss connecting Square Payroll with your Tallyfy workflows. - **[Microsoft Teams](https://tallyfy.com/products/pro/integrations/vendors/teams/)**: Microsoft Teams handles communication but lacks process management capabilities like request tracking and accountability so Tallyfy fills this gap by converting Teams messages into structured workflows with assigned owners and deadlines through Power Automate or custom integrations. ## The gap Teams cannot fill Microsoft Teams is where your team communicates. But communication is not process. When someone asks "can you approve this?" in a Teams message, there's no assigned owner, no deadline, no escalation. If the message gets buried in a busy channel, the work doesn't happen. Teams cannot track whether a request was completed or hold anyone accountable for it. Teams Approvals (built on Power Automate) handles simple linear approvals, but cannot manage complex multi-step processes with conditional routing, parallel tasks, or cross-department coordination. **What Teams handles:** - Real-time messaging and channels - Video meetings and calls - File sharing via SharePoint - Basic approvals via Power Automate **What falls through the cracks:** - Request tracking with clear ownership and deadlines - Complex approval workflows spanning multiple departments - SLA enforcement and automatic escalation - Process visibility and completion metrics - Conditional routing based on request type or data - Audit trails for compliance requirements Teams is where teams talk. Tallyfy is where work gets tracked and completed. The integration bridges conversation to action. ## How Tallyfy fills this gap When a request is made in Teams, Tallyfy creates a structured workflow with assigned owners, deadlines, and escalation rules. Every step is tracked, and nothing gets lost in chat history. ### Request management Turn Teams messages into tracked work: - Convert any message into a Tallyfy task with one click - Launch structured workflows from slash commands - Collect request details via forms before creating work - Link Teams conversations to Tallyfy tasks for context ### Process execution Complete workflows without leaving Teams: - Receive task notifications in your activity feed - Approve or reject requests directly from Teams - Post workflow status updates to channels automatically - Track progress across all your assigned work ### Team coordination Combine Teams collaboration with structured workflows: - New channel creation triggers project setup workflows - Guest access triggers compliance and security reviews - Document uploads trigger review and approval processes - Meeting action items become tracked Tallyfy tasks ## Connect today **Power Automate**: The primary connection method. Use [Power Automate](/products/pro/integrations/middleware/power-automate/) to trigger Tallyfy workflows from Teams events and post updates back to channels. **Microsoft Graph API**: Build custom Teams apps that integrate with Tallyfy using Adaptive Cards and Bot Framework. **Webhooks**: Send Tallyfy workflow updates to Teams channels via incoming webhooks. For technical implementation details including code examples and Adaptive Cards, see [Teams technical integration](/products/pro/integrations/vendors/teams/technical/). ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss connecting Microsoft Teams with your Tallyfy workflows. We'll show you how to turn conversations into tracked processes. - **[TriNet](https://tallyfy.com/products/pro/integrations/vendors/trinet/)**: Tallyfy complements TriNet's PEO services by orchestrating the cross-department workflows that employee events trigger - coordinating IT provisioning facilities preparation training schedules and equipment tracking across all teams beyond what HR administration alone can manage. ## The gap TriNet cannot fill TriNet provides full PEO services - handling payroll, benefits, and HR compliance for SMBs. But PEO services focus on HR administration, not coordinating the business processes that employee events trigger. When TriNet processes a new hire, they handle the employment paperwork. But IT needs to create accounts. Facilities needs to prepare workspace. Training needs to schedule orientation. Finance needs to set up expense access. TriNet cannot coordinate these cross-department handoffs. **What TriNet manages:** - Co-employment and payroll processing - Benefits administration and compliance - HR consulting and risk management - Employee records and documentation **What falls through the cracks:** - Cross-department coordination beyond HR - IT provisioning and system access setup - Facilities and workspace preparation - Training schedule coordination - Multi-stakeholder approval workflows TriNet serves your HR outsourcing needs. But business processes span every department. Tallyfy orchestrates workflows across ALL your teams - not just one. ## How Tallyfy fills this gap When a TriNet employee event fires - hire, termination, status change - Tallyfy launches a structured workflow that coordinates stakeholders both inside and outside the PEO relationship. ### Employee onboarding When TriNet records a new hire, Tallyfy orchestrates: - IT account and system access provisioning - Equipment ordering and delivery tracking - Training enrollment and compliance tracking - Finance expense and corporate card setup - Manager welcome and introduction workflows ### Offboarding coordination When TriNet processes a termination, Tallyfy ensures: - IT access revocation on the correct date - Equipment return tracking - Knowledge transfer workflows - Exit interview scheduling ## Connect today **Middleware**: Connect via [Zapier](/products/pro/integrations/middleware/zapier/), [Power Automate](/products/pro/integrations/middleware/power-automate/), or [Workato](/products/pro/integrations/middleware/workato/). **HR Integration Platforms**: Merge and Finch offer unified API access including TriNet. **API**: Build custom integration using [Tallyfy's API](/products/pro/integrations/open-api/) with TriNet's customer APIs. ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss connecting TriNet with your Tallyfy workflows. - **[UiPath](https://tallyfy.com/products/pro/integrations/vendors/uipath/)**: UiPath handles task automation but lacks the ability to orchestrate complete business processes that require coordination between automated bots and human workers which Tallyfy addresses through its process orchestration layer that manages handoffs exception handling and end-to-end visibility across both automated and manual workflow steps. ## The gap UiPath cannot fill UiPath excels at automating repetitive, rule-based tasks on screens. But most business processes require BOTH automated AND human activities - and UiPath cannot orchestrate both. When a UiPath bot completes data extraction from an invoice, what happens next? Who reviews exceptions? What if the bot encounters an edge case? How do you track whether the full process completed? UiPath automates individual tasks - it cannot coordinate entire processes that span bots and humans. **What UiPath automates:** - Screen scraping and data extraction - Form filling and data entry - Rule-based decisions on structured data - Legacy system interactions via UI **What falls through the cracks:** - Handoffs between bots and human workers - Exception handling requiring human judgment - End-to-end process visibility across automated and manual steps - Accountability for process outcomes - Conditional routing to different teams based on exceptions - Coordination across multiple bots and humans UiPath automates tasks. Tallyfy orchestrates processes - combining bots and humans in unified workflows with complete visibility. ## How Tallyfy fills this gap Tallyfy serves as the orchestration layer that connects UiPath with human workflows, creating end-to-end process automation. ### Process orchestration When UiPath bots execute, Tallyfy: - Triggers the right bot at the right time via webhooks - Routes exceptions to human reviewers immediately - Tracks completion across all steps - automated and manual - Escalates when SLAs are at risk ### Human-bot handoffs Tallyfy manages seamless transitions: - Bot completes data extraction → Tallyfy assigns human review - Human approves exception → Tallyfy triggers next bot via Orchestrator API - Complete audit trail of who did what and when ### Exception management When UiPath encounters something it cannot handle: - Tallyfy receives the exception notification - Routes to the appropriate human reviewer - Tracks resolution time and outcome - Resumes automation once exception is resolved ## Connect today **UiPath Orchestrator API**: Trigger UiPath jobs from Tallyfy webhooks and receive completion notifications. **Middleware**: Connect via [Zapier](/products/pro/integrations/middleware/zapier/) or [Power Automate](/products/pro/integrations/middleware/power-automate/) for simpler integration patterns. **API**: Use [Tallyfy's API](/products/pro/integrations/open-api/) to trigger workflows when bots complete and call Orchestrator endpoints when human tasks finish. **See also**: [Combining RPA systems and human operators](/products/pro/integrations/open-api/how-does-tallyfy-combine-rpa-systems-and-human-operators/) ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss orchestrating UiPath with your Tallyfy workflows. We'll help you identify processes where human-bot coordination can reduce exceptions and improve completion rates. - **[Slack](https://tallyfy.com/products/pro/integrations/vendors/slack/)**: Connect Slack with Tallyfy to transform conversations into tracked workflows with clear ownership, deadlines, and accountability - turning chat requests into structured processes that don't get buried. ## The gap Slack cannot fill Slack is where your team communicates. But communication is not process. When someone asks "can you approve this?" in a Slack message, there's no owner, no deadline, no escalation. If the message gets buried in a busy channel, the work doesn't happen. Slack has no way to track whether a request was completed or who is responsible for it. **What Slack handles:** - Real-time team messaging - Channel-based conversations - File sharing and search - Video calls and huddles **What falls through the cracks:** - Request tracking with clear ownership and deadlines - Approval workflows with accountability and audit trails - SLA enforcement and automatic escalation - Process visibility across the organization - Completion tracking and performance metrics Slack is where teams talk. Tallyfy is where work gets tracked and completed. The integration bridges conversation to action. ## Native integration available ### What you can do | Feature | Description | |---------|-------------| | Create task | Turn any Slack message into a tracked Tallyfy task | | Launch process | Start a Tallyfy workflow from a Slack conversation | | Get notifications | Receive Slack alerts when tasks are assigned, completed, or due | | Link conversations | Connect Slack messages to Tallyfy tasks for context | | Track progress | View and update task status from either platform | ### Installation 1. Find the Tallyfy app in the [Slack App Directory](https://slack.com/apps/AF15436JJ-tallyfy) or on the [Tallyfy integrations page](https://tallyfy.com/integrations/) 2. Click **Add to Slack** 3. Choose your workspace and authorize the permissions 4. Connect your Tallyfy account ### Using the integration **Create a task from a message:** 1. Hover over any Slack message 2. Click the **More actions** menu (three dots) 3. Select **Create Tallyfy Task** 4. Fill in task details and click **Create** **Launch a workflow:** 1. Type `/tallyfy launch` in any channel 2. Select a template from the menu 3. Fill out the kick-off form 4. Click **Launch** **Check your tasks:** 1. Type `/tallyfy tasks` in any channel 2. View your current task list 3. Click any task to see details or update status ## Troubleshooting If the integration isn't working: - Verify your Tallyfy account has permission to create tasks and launch processes - Check that the Tallyfy app is properly authorized in your Slack workspace - Ask IT if firewall settings might block notifications - Contact [Tallyfy support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/) if issues persist ## Get started Install the [Tallyfy Slack app](https://slack.com/apps/AF15436JJ-tallyfy) to start turning conversations into tracked workflows. - **[Zendesk](https://tallyfy.com/products/pro/integrations/vendors/zendesk/)**: Zendesk captures customer support tickets across channels but lacks the ability to orchestrate structured multi-team workflows needed for complex issue resolution which is where Tallyfy serves as an orchestration layer to launch investigation workflows assign accountable tasks enforce escalation deadlines and manage post-resolution processes like root cause analysis and knowledge base updates. ## The gap Zendesk cannot fill Zendesk excels at capturing customer conversations across channels - email, chat, phone, social. But tickets are inherently unstructured. They capture what was said, not what needs to happen next. When a support ticket requires action from multiple teams - engineering needs to investigate, product needs to evaluate, documentation needs updating - Zendesk tracks the conversation. It doesn't orchestrate the cross-team workflow that actually resolves the issue. **What Zendesk manages:** - Multi-channel ticket capture - Agent assignment and routing - Customer communication history - Knowledge base articles **What falls through the cracks:** - Structured workflows after ticket creation - Multi-team coordination with accountability - Escalation workflows with enforced deadlines - Post-resolution follow-up processes - Root cause analysis workflows - Product improvement tracking from support issues Zendesk captures support requests. Tallyfy transforms them into structured processes that ensure nothing falls through the cracks. ## How Tallyfy fills this gap Tallyfy serves as the orchestration layer that connects Zendesk tickets with the structured workflows needed to fully resolve complex issues. ### Structured resolution workflows When tickets need more than a reply, Tallyfy: - Launches multi-step investigation workflows - Assigns tasks to specific teams with deadlines - Tracks completion across all involved parties - Provides visibility into resolution progress ### Escalation management When issues need escalation, Tallyfy: - Routes to the right managers based on issue type - Enforces SLA-driven deadlines - Documents escalation history - Ensures follow-through on commitments ### Post-resolution processes When tickets close in Zendesk, Tallyfy orchestrates: - Root cause analysis workflows - Knowledge base update processes - Customer follow-up sequences - Product improvement tracking ## Connect today **Middleware**: Connect via [Zapier](/products/pro/integrations/middleware/zapier/) or [Make](/products/pro/integrations/middleware/make/) to trigger Tallyfy workflows from Zendesk ticket events. **API**: Build custom integration using [Tallyfy's API](/products/pro/integrations/open-api/) with Zendesk's REST API. **See also**: [Tickets vs. Processes](/products/pro/tutorials/features/ticket-driven-vs-process-driven/) - Why structured processes beat unstructured tickets. ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss connecting Zendesk with your Tallyfy workflows. We'll map your complex ticket types to the structured processes that resolve them completely. - **[Zenefits](https://tallyfy.com/products/pro/integrations/vendors/zenefits/)**: Zenefits handles HR administration but falls short when employee events require coordination across multiple departments like IT provisioning and facilities setup which Tallyfy addresses through structured cross-department workflows. ## The gap Zenefits cannot fill Zenefits (now TriNet Zenefits) provides all-in-one HR for SMBs - HR, benefits, payroll, and compliance. But the moment HR events trigger cross-department coordination, processes fall outside Zenefits' scope. When Zenefits records a new hire, the HR system handles paperwork and benefits enrollment. But IT needs to provision accounts. Facilities needs workspace setup. Training needs to schedule onboarding. These cross-department processes require coordination beyond what Zenefits provides. **What Zenefits manages:** - HR administration and employee records - Benefits administration and enrollment - Payroll processing - Compliance documentation **What falls through the cracks:** - Cross-department process coordination - IT provisioning and access management - Equipment ordering and tracking - Multi-stakeholder approval chains - External vendor and contractor workflows Zenefits serves your SMB HR needs. But employee processes span every department. Tallyfy orchestrates workflows across ALL your teams - not just one. ## How Tallyfy fills this gap When a Zenefits employee event fires - hire, benefits change, time-off request, departure - Tallyfy launches a structured workflow that coordinates every downstream team. ### Employee onboarding When Zenefits records a new hire, Tallyfy orchestrates: - IT account setup and equipment provisioning - Facilities workspace and building access - Training schedule and compliance tracking - Finance expense account configuration - Team introduction workflows ### Benefits coordination When Zenefits processes benefits changes, Tallyfy handles: - Multi-step enrollment verification workflows - Dependent documentation collection - Payroll deduction confirmations - Compliance documentation tracking ## Connect today **HR Integration Platforms**: Finch and Merge offer unified API access including Zenefits - often the fastest path to integration. **Middleware**: Connect via [Zapier](/products/pro/integrations/middleware/zapier/), [Make](/products/pro/integrations/middleware/make/), or [Workato](/products/pro/integrations/middleware/workato/). **API**: Build custom integration using [Tallyfy's API](/products/pro/integrations/open-api/) with unified HR API providers. ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss connecting Zenefits with your Tallyfy workflows. - **[UKG Pro](https://tallyfy.com/products/pro/integrations/vendors/ukg-pro/)**: Tallyfy serves as an orchestration layer that bridges UKG Pro's workforce management capabilities with cross-department process coordination by providing faster integrations and self-service workflows that UKG's multi-database architecture and lengthy implementation timelines cannot deliver on their own. ## The gap UKG Pro cannot fill UKG Pro provides deep workforce management, scheduling, and HR capabilities for large enterprises. But UKG's multi-database architecture means integration projects can take many months, support response times can stretch significantly, and cross-department coordination requires manual intervention. UKG Pro stores workforce data but cannot easily coordinate the handoffs between HR, IT, Finance, and Operations that employee changes require. Data lives in multiple internal stores, creating consistency challenges and extra steps for simple processes. **What UKG Pro manages:** - Workforce scheduling and labor management - HR administration and employee records - Time and attendance tracking - Leave management and accruals **What falls through the cracks:** - Integration timelines stretching many months - Support bottlenecks causing weeks of delays - Data reconciliation across multiple internal databases - Cross-department workflow coordination - Reporting that requires extensive configuration - Self-service workflows for common HR requests UKG Pro serves enterprise workforce management. But process coordination requires faster, more flexible orchestration. Tallyfy provides the workflow layer that bridges UKG data with cross-team execution. ## How Tallyfy fills this gap Tallyfy acts as the orchestration layer between UKG Pro and your cross-department processes, providing speed and visibility that UKG's architecture cannot deliver alone. ### Accelerated integrations Instead of waiting months for UKG integrations: - Connect via middleware while native integration develops - Validate data before it flows to downstream systems - Track handoffs with clear ownership and deadlines - Route exceptions to the right people automatically ### Self-service workflows Create workflows that don't require months of UKG configuration: - Report request workflows with automatic distribution - HR request routing without support tickets - Succession planning with flexible customization - Benefits verification and reconciliation ## Connect today **Middleware**: Connect via [Zapier](/products/pro/integrations/middleware/zapier/), [Workato](/products/pro/integrations/middleware/workato/), or [Celigo](/products/pro/integrations/middleware/celigo/). **HR Integration Platforms**: Merge recently partnered with UKG for unified API access. **API**: Build custom integration using [Tallyfy's API](/products/pro/integrations/open-api/) with UKG's APIs. ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss connecting UKG Pro with your Tallyfy workflows. - **[Zoho CRM](https://tallyfy.com/products/pro/integrations/vendors/zoho-crm/)**: Tallyfy complements Zoho CRM by orchestrating complex cross-department workflows and micro-tasks that occur between sales pipeline stages - handling coordination with non-Zoho users and multi-level approvals that Zoho's native automation cannot manage on its own. ## The gap Zoho CRM cannot fill Zoho CRM tracks your deals through pipeline stages as part of the broader Zoho ecosystem. But even with Zoho's extensive suite, the micro-tasks between sales stages require coordination that spans people and departments - not just apps. When a deal moves from qualification to proposal in Zoho CRM, multiple team members need to complete specific tasks in sequence. Technical scoping, pricing approval, legal review, resource allocation - each requires assignment, deadlines, and accountability. Zoho's Blueprint workflows help with simple sequences, but not complex cross-department coordination. **What Zoho CRM manages:** - Lead and contact management - Deal pipeline and stages - Sales automation (Blueprint) - Suite integration (Zoho One) **What falls through the cracks:** - Micro-tasks between each sales stage - Cross-department handoffs with accountability - Complex approval chains beyond simple approvals - Involvement of non-Zoho users in workflows - Post-sale onboarding spanning multiple teams - Audit trails for deal execution Zoho CRM automates within its ecosystem. Tallyfy orchestrates across all your teams - whether they use Zoho or not. ## How Tallyfy fills this gap Tallyfy serves as the orchestration layer that connects Zoho CRM stage changes with the detailed workflows that must happen between them. ### Cross-department coordination When deals progress in Zoho CRM, Tallyfy: - Assigns tasks to people regardless of which tools they use - Coordinates between Zoho users and non-Zoho teams - Enforces deadlines with automatic escalation - Provides visibility across all participants ### Approval workflows When deals require approvals, Tallyfy: - Routes to the right approvers based on deal characteristics - Handles multi-level approval chains - Tracks approval history and timing - Escalates delayed approvals automatically ### Post-sale handoffs When deals close in Zoho CRM, Tallyfy orchestrates: - Customer success handoff - Implementation coordination - Account setup across all systems - Training and enablement workflows ## Connect today **Middleware**: Connect via [Zapier](/products/pro/integrations/middleware/zapier/) or [Make](/products/pro/integrations/middleware/make/) to trigger Tallyfy workflows from Zoho CRM events. **Zoho Flow**: Use Zoho Flow to connect Zoho CRM with Tallyfy's API. **API**: Build custom integration using [Tallyfy's API](/products/pro/integrations/open-api/) with Zoho's REST APIs. **See also**: [Integrate to your CRM or ERP](/products/pro/integrations/middleware/integrate-into-crm/) ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss connecting Zoho CRM with your Tallyfy workflows. - **[WorkFusion](https://tallyfy.com/products/pro/integrations/vendors/workfusion/)**: Tallyfy orchestrates the complete process by coordinating WorkFusion's AI automation with human oversight exception handling and approval workflows to fill gaps that AI cannot handle alone. ## The gap WorkFusion cannot fill WorkFusion combines AI and RPA to automate complex, judgment-intensive processes. Its machine learning models improve over time, handling increasingly sophisticated decisions. But even the best AI cannot handle every scenario - human expertise is essential for edge cases, model training, and final approvals. When WorkFusion's AI processes a complex claim, borderline cases still need human judgment. When it classifies documents, new document types need human guidance. When it makes a decision, high-stakes outcomes need human oversight. WorkFusion augments human work - but cannot orchestrate the human activities that surround its automation. **What WorkFusion automates:** - AI-powered document processing - Intelligent automation with machine learning - Complex decision automation - Continuous learning from human feedback **What falls through the cracks:** - Human-in-the-loop orchestration for model training - Exception escalation to subject matter experts - Approval workflows for high-stakes AI decisions - Process visibility spanning AI automation and human work - Accountability for end-to-end outcomes - Coordination when AI confidence is low WorkFusion augments human decision-making with AI. Tallyfy orchestrates the complete process - coordinating AI automation with human oversight, exception handling, and approval workflows. ## How Tallyfy fills this gap Tallyfy serves as the orchestration layer that connects WorkFusion AI automation with human workflows. ### Human-in-the-loop coordination When WorkFusion processes work, Tallyfy manages: - Routing low-confidence items to human reviewers - Collecting human decisions to improve AI models - Escalating edge cases to subject matter experts - Tracking human-AI collaboration metrics ### AI-human handoffs Tallyfy ensures smooth transitions: - AI processes routine items automatically - Borderline cases route to human review queue - Human decisions feed back to improve AI - High-stakes items always include human approval ### Exception management When AI encounters uncertainty: - WorkFusion flags item with confidence score - Tallyfy routes based on confidence thresholds - Specialist reviews and decides - Decision recorded for model improvement ## Connect today **WorkFusion API**: Trigger Tallyfy workflows when AI processing completes and receive human decisions back. **Middleware**: Connect via enterprise integration platforms. **API**: Use [Tallyfy's API](/products/pro/integrations/open-api/) to orchestrate human-AI workflows. **See also**: [Combining RPA systems and human operators](/products/pro/integrations/open-api/how-does-tallyfy-combine-rpa-systems-and-human-operators/) ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss orchestrating WorkFusion with your Tallyfy workflows. We'll help you build effective human-in-the-loop processes that improve AI performance over time. - **[Workday](https://tallyfy.com/products/pro/integrations/vendors/workday/)**: Connect Workday with Tallyfy to orchestrate cross-department processes like onboarding, role changes, and compliance workflows that Workday cannot coordinate on its own - spanning IT, Facilities, Training, and Finance teams. ## The gap Workday cannot fill Workday centralizes HR and financial data for large enterprises. But the moment someone is hired in Workday, a cascade of coordination begins that Workday doesn't handle. Workday cannot tell IT to order a laptop. It cannot tell Facilities to assign a desk. It cannot schedule orientation with Training or notify Finance to create an expense account. These handoffs happen in emails, spreadsheets, and chat threads - untracked and invisible. **What Workday manages:** - Employee records and organizational structure - Payroll processing and compensation data - Benefits administration and time tracking - Financial transactions and reporting **What falls through the cracks:** - Cross-department coordination for onboarding and offboarding - Multi-stakeholder approval chains spanning HR, IT, Finance, and Legal - Real-time visibility into process completion across teams - Conditional routing based on role, location, or department - Structured handoffs with clear ownership and deadlines - Process improvement from historical completion data Workday serves your HR and Finance teams. But employee lifecycle processes span every department. Tallyfy orchestrates workflows across ALL your teams - not just one. ## How Tallyfy fills this gap When a Workday employee event fires - hire, termination, role change - Tallyfy launches a structured workflow that coordinates every downstream action. Every step has an owner, a deadline, and escalation rules if something stalls. ### Employee onboarding When Workday records a new hire, Tallyfy orchestrates: - IT equipment provisioning and system access - Facilities desk assignment and building access - Training schedule and compliance certifications - Finance expense account and corporate card setup - Manager introductions and team integration ### Role changes and transfers When Workday records a promotion or transfer, Tallyfy coordinates: - Access permission updates across systems - Equipment changes for new responsibilities - Training requirements for the new role - Announcement and knowledge transfer workflows ### Offboarding When Workday records a termination, Tallyfy ensures: - IT access revocation on the correct date - Equipment return tracking - Knowledge transfer completion - Exit interview scheduling - Final payroll coordination ## Connect today **Middleware**: Connect via [Zapier](/products/pro/integrations/middleware/zapier/), [Power Automate](/products/pro/integrations/middleware/power-automate/), [Workato](/products/pro/integrations/middleware/workato/), or [Celigo](/products/pro/integrations/middleware/celigo/). **iPaaS Partners**: MuleSoft and Boomi have pre-built Workday connectors that can trigger Tallyfy workflows. **API**: Build custom integration using [Tallyfy's API](/products/pro/integrations/open-api/) with Workday's REST APIs or Integration Cloud. For technical implementation details including code examples and data mapping, see [Workday technical integration](/products/pro/integrations/vendors/workday/technical/). ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss connecting Workday with your Tallyfy workflows. We'll analyze your current Workday configuration and identify high-impact automation opportunities. ### Bamboohr - **[BambooHR technical integration](https://tallyfy.com/products/pro/integrations/vendors/bamboohr/technical/)**: Technical implementation details for connecting BambooHR with Tallyfy including REST API examples, webhook signatures, data mapping, and authentication configuration for HR workflows. ## Integration options BambooHR provides REST APIs with webhook support. Their API uses simple API key authentication and supports SHA-256 HMAC webhook signatures. ### REST API integration Use BambooHR's REST API to fetch employee data and trigger Tallyfy workflows: ```javascript const handleBambooHREmployee = async (employeeId) => { const employee = await fetch( `https://api.bamboohr.com/api/gateway.php/${subdomain}/v1/employees/${employeeId}`, { headers: { 'Authorization': `Basic ${Buffer.from(apiKey + ':x').toString('base64')}`, 'Accept': 'application/json' } } ).then(res => res.json()); const workflow = await fetch('https://api.tallyfy.com/v1/workflows', { method: 'POST', headers: { 'Authorization': 'Bearer YOUR_TALLYFY_KEY', 'Content-Type': 'application/json' }, body: JSON.stringify({ template_id: 'employee_onboarding', name: `Onboarding - ${employee.firstName} ${employee.lastName}`, data: { employee_id: employee.id, full_name: `${employee.firstName} ${employee.lastName}`, email: employee.workEmail, department: employee.department, location: employee.location, job_title: employee.jobTitle, manager: employee.supervisor, start_date: employee.hireDate } }) }); return workflow.json(); }; ``` ### Webhook integration BambooHR webhooks use SHA-256 HMAC signatures for verification: ```javascript const express = require('express'); const crypto = require('crypto'); const app = express(); app.post('/bamboohr-webhook', express.raw({ type: '*/*' }), async (req, res) => { // Verify webhook signature using SHA-256 HMAC const signature = req.headers['x-bamboohr-signature']; const expectedSignature = crypto .createHmac('sha256', process.env.BAMBOOHR_WEBHOOK_SECRET) .update(req.body) .digest('hex'); if (signature !== expectedSignature) { return res.status(401).send('Invalid signature'); } const payload = JSON.parse(req.body); const { type, employees } = payload; for (const employeeId of employees) { switch (type) { case 'employee': await launchOnboardingWorkflow(employeeId); break; case 'job_information': await launchRoleChangeWorkflow(employeeId); break; case 'employment_status': await handleStatusChange(employeeId); break; } } res.status(200).send('OK'); }); ``` ### Polling for changes BambooHR also supports change reports for systems that cannot receive webhooks: ```javascript const pollBambooHRChanges = async () => { const since = new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString(); const changes = await fetch( `https://api.bamboohr.com/api/gateway.php/${subdomain}/v1/employees/changed?since=${since}`, { headers: { 'Authorization': `Basic ${Buffer.from(apiKey + ':x').toString('base64')}`, 'Accept': 'application/json' } } ).then(res => res.json()); for (const employee of changes.employees) { await processEmployeeChange(employee.id, employee.action); } }; ``` ## Data mapping Common BambooHR fields to map to Tallyfy workflow variables: | BambooHR Field | Tallyfy Variable | Description | |----------------|------------------|-------------| | `id` | `employee_id` | Employee record ID | | `firstName` + `lastName` | `full_name` | Employee name | | `workEmail` | `email` | Work email address | | `department` | `department` | Department name | | `division` | `division` | Division name | | `location` | `location` | Work location | | `jobTitle` | `job_title` | Job title | | `supervisor` | `manager` | Direct supervisor name | | `supervisorEmail` | `manager_email` | Supervisor email | | `hireDate` | `start_date` | Hire date | | `employmentHistoryStatus` | `status` | Current employment status | ## Authentication BambooHR uses API key authentication with HTTP Basic auth. The API key is the username and 'x' is the password. ```javascript const getBambooHRHeaders = () => ({ 'Authorization': `Basic ${Buffer.from(process.env.BAMBOOHR_API_KEY + ':x').toString('base64')}`, 'Accept': 'application/json' }); ``` ## Available webhook events BambooHR webhooks can trigger on various field changes: - **Employee created** - New employee added - **Job information** - Title, department, or location changed - **Employment status** - Status changed (active, terminated, on leave) - **Compensation** - Salary or pay rate changed - **Time off** - Time off requests or balances changed ## iPaaS alternatives If direct API development is not available: - **Merge API**: Unified HRIS API with BambooHR support - **Finch**: Employment system API - **Zapier**: Pre-built BambooHR triggers and actions - **Make**: Visual workflow builder with BambooHR connector ### Netsuite - **[NetSuite technical integration](https://tallyfy.com/products/pro/integrations/vendors/netsuite/technical/)**: This technical documentation outlines methods for integrating NetSuite with Tallyfy including REST API with OAuth 2.0 authentication and native SuiteScript development for triggering workflows on record events along with data field mappings and iPaaS platform alternatives like Celigo and Workato. ## Integration options NetSuite emphasizes REST APIs as the preferred integration method. Choose based on your technical requirements. ### REST API integration (recommended) Use OAuth 2.0 authentication with NetSuite's REST API: ```javascript const handleEmployeeHire = async (employeeData) => { const employee = await netsuiteAPI.get(`/employee/${employeeData.id}`, { expand: ['department', 'location', 'subsidiary', 'supervisor'] }); const workflow = await fetch('https://api.tallyfy.com/v1/workflows', { method: 'POST', headers: { 'Authorization': 'Bearer YOUR_TALLYFY_KEY', 'Content-Type': 'application/json' }, body: JSON.stringify({ template_id: 'netsuite_onboarding', name: `Onboarding - ${employee.entityId}`, data: { employee_id: employee.id, full_name: `${employee.firstName} ${employee.lastName}`, email: employee.email, subsidiary: employee.subsidiary.name, department: employee.department.name, location: employee.location.name, supervisor: employee.supervisor.name } }) }); return workflow.json(); }; ``` ### SuiteScript integration Build native NetSuite scripts that trigger on record events: ```javascript /** * @NApiVersion 2.1 * @NScriptType UserEventScript */ define(['N/https', 'N/record'], function(https, record) { function afterSubmit(context) { if (context.type === context.UserEventType.CREATE) { const employee = context.newRecord; https.post({ url: 'https://api.tallyfy.com/v1/workflows', headers: { 'Authorization': 'Bearer YOUR_KEY', 'Content-Type': 'application/json' }, body: JSON.stringify({ template_id: 'employee_onboarding', data: { employee_id: employee.id, name: employee.getValue('entityid') } }) }); } } return { afterSubmit: afterSubmit }; }); ``` ## Data mapping Common NetSuite fields to map to Tallyfy workflow variables: | NetSuite Field | Tallyfy Variable | Description | |----------------|------------------|-------------| | `id` | `employee_id` | Internal record ID | | `entityId` | `entity_id` | Employee number | | `firstName` + `lastName` | `full_name` | Employee name | | `email` | `email` | Email address | | `subsidiary.name` | `subsidiary` | Legal entity | | `department.name` | `department` | Department name | | `location.name` | `location` | Office location | | `supervisor.name` | `manager` | Direct manager | | `title` | `job_title` | Job title | | `employeeType` | `employee_type` | Employment type | ## iPaaS alternatives If SuiteScript development is not available: - **Celigo**: NetSuite-native integration platform - **Workato**: Enterprise automation with NetSuite recipes - **Boomi**: Dell Boomi AtomSphere with NetSuite connectors - **MuleSoft**: Anypoint Platform with NetSuite support ### Paylocity - **[Paylocity technical integration](https://tallyfy.com/products/pro/integrations/vendors/paylocity/technical/)**: Technical implementation details for connecting Paylocity with Tallyfy including REST API examples, webhook handling, data mapping, and authentication configuration for HR workflows. ## Integration options Paylocity offers REST APIs through their developer program. Choose based on your integration requirements and partnership status. ### REST API integration Use Paylocity's REST API to trigger Tallyfy workflows on employee events: ```javascript const handlePaylocityEvent = async (event) => { if (event.eventType === 'employee.created') { const employee = await paylocityAPI.get(`/v2/companies/${companyId}/employees/${event.employeeId}`); const workflow = await fetch('https://api.tallyfy.com/v1/workflows', { method: 'POST', headers: { 'Authorization': 'Bearer YOUR_TALLYFY_KEY', 'Content-Type': 'application/json' }, body: JSON.stringify({ template_id: 'employee_onboarding', name: `Onboarding - ${employee.firstName} ${employee.lastName}`, data: { employee_id: employee.employeeId, full_name: `${employee.firstName} ${employee.lastName}`, email: employee.workEmail, department: employee.departmentCode, location: employee.workLocation, job_title: employee.jobTitle, manager: employee.supervisorFirstName + ' ' + employee.supervisorLastName, start_date: employee.hireDate } }) }); return workflow.json(); } }; ``` ### Webhook integration Register webhooks to receive real-time notifications from Paylocity: ```javascript const express = require('express'); const crypto = require('crypto'); const app = express(); app.post('/paylocity-webhook', express.json(), async (req, res) => { // Verify webhook signature const signature = req.headers['x-paylocity-signature']; const payload = JSON.stringify(req.body); const expectedSignature = crypto .createHmac('sha256', process.env.PAYLOCITY_WEBHOOK_SECRET) .update(payload) .digest('hex'); if (signature !== expectedSignature) { return res.status(401).send('Invalid signature'); } const { eventType, data } = req.body; switch (eventType) { case 'employee.hired': await launchOnboardingWorkflow(data); break; case 'employee.terminated': await launchOffboardingWorkflow(data); break; case 'payroll.completed': await launchPayrollReviewWorkflow(data); break; } res.status(200).send('OK'); }); ``` ## Data mapping Common Paylocity fields to map to Tallyfy workflow variables: | Paylocity Field | Tallyfy Variable | Description | |-----------------|------------------|-------------| | `employeeId` | `employee_id` | Unique employee identifier | | `firstName` + `lastName` | `full_name` | Employee full name | | `workEmail` | `email` | Work email address | | `departmentCode` | `department` | Department code | | `costCenter` | `cost_center` | Cost center assignment | | `workLocation` | `location` | Work location code | | `jobTitle` | `job_title` | Job title | | `supervisorFirstName` | `manager` | Direct supervisor | | `employeeType` | `employee_type` | Full-time, part-time, contractor | | `hireDate` | `start_date` | Employee start date | ## Authentication Paylocity uses OAuth 2.0 with client credentials flow. Store credentials securely and never expose them in client-side code. ```javascript const getPaylocityToken = async () => { const response = await fetch('https://api.paylocity.com/IdentityServer/connect/token', { method: 'POST', headers: { 'Content-Type': 'application/x-www-form-urlencoded' }, body: new URLSearchParams({ grant_type: 'client_credentials', client_id: process.env.PAYLOCITY_CLIENT_ID, client_secret: process.env.PAYLOCITY_CLIENT_SECRET, scope: 'WebLinkAPI' }) }); return response.json(); }; ``` ## iPaaS alternatives If direct API development is not available: - **Merge API**: Unified HRIS API with Paylocity support - **Finch**: Employment system API with Paylocity connector - **Flexspring**: HR integration platform - **Workato**: Enterprise automation recipes ### Teams - **[Teams technical integration](https://tallyfy.com/products/pro/integrations/vendors/teams/technical/)**: Technical implementation details for connecting Microsoft Teams with Tallyfy including Adaptive Cards, Graph API examples, Power Automate patterns, and Bot Framework configuration for workflow integration. ## Integration options Microsoft Teams integration uses Microsoft Graph API, Adaptive Cards, and Power Automate. Choose based on your integration requirements. ### Power Automate (recommended) The simplest path uses Power Automate as middleware between Teams and Tallyfy: ```text Trigger: When a message is posted to a channel Action: HTTP POST to Tallyfy API Action: Post Adaptive Card to Teams with workflow link ``` ### Adaptive Cards for task notifications Send rich, interactive cards to Teams channels when Tallyfy tasks are assigned: ```json { "$schema": "http://adaptivecards.io/schemas/adaptive-card.json", "type": "AdaptiveCard", "version": "1.4", "body": [ { "type": "TextBlock", "text": "New Task Assigned", "weight": "Bolder", "size": "Medium" }, { "type": "FactSet", "facts": [ { "title": "Task:", "value": "${taskTitle}" }, { "title": "Process:", "value": "${processName}" }, { "title": "Due:", "value": "${dueDate}" }, { "title": "Assigned by:", "value": "${assignedBy}" } ] }, { "type": "TextBlock", "text": "${taskDescription}", "wrap": true } ], "actions": [ { "type": "Action.OpenUrl", "title": "Open in Tallyfy", "url": "${taskUrl}" }, { "type": "Action.Submit", "title": "Mark Complete", "data": { "action": "complete", "taskId": "${taskId}" } } ] } ``` ### Microsoft Graph API integration Post workflow updates to Teams channels using Graph API: ```javascript const { Client } = require('@microsoft/microsoft-graph-client'); const postToTeamsChannel = async (channelId, teamId, message, card) => { const client = Client.init({ authProvider: (done) => done(null, accessToken) }); await client .api(`/teams/${teamId}/channels/${channelId}/messages`) .post({ body: { contentType: 'html', content: message }, attachments: [{ contentType: 'application/vnd.microsoft.card.adaptive', content: JSON.stringify(card) }] }); }; // Example: Post when Tallyfy workflow completes const notifyWorkflowComplete = async (workflow) => { const card = { type: 'AdaptiveCard', version: '1.4', body: [{ type: 'TextBlock', text: `✅ Workflow Complete: ${workflow.name}`, weight: 'Bolder' }, { type: 'FactSet', facts: [ { title: 'Completed by:', value: workflow.completedBy }, { title: 'Duration:', value: workflow.duration }, { title: 'Tasks:', value: `${workflow.completedTasks}/${workflow.totalTasks}` } ] }] }; await postToTeamsChannel(channelId, teamId, 'Workflow completed', card); }; ``` ### Incoming webhooks For simpler scenarios, use Teams incoming webhooks: ```javascript const postToTeamsWebhook = async (webhookUrl, message) => { await fetch(webhookUrl, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ '@type': 'MessageCard', '@context': 'http://schema.org/extensions', summary: message.title, themeColor: '0076D7', title: message.title, sections: [{ activityTitle: message.subtitle, facts: message.facts, text: message.body }], potentialAction: [{ '@type': 'OpenUri', name: 'View in Tallyfy', targets: [{ os: 'default', uri: message.url }] }] }) }); }; ``` ## Bot Framework integration Build a custom Teams bot for richer interaction: ```javascript const { TeamsActivityHandler, CardFactory } = require('botbuilder'); class TallyfyBot extends TeamsActivityHandler { constructor() { super(); this.onMessage(async (context, next) => { const text = context.activity.text.toLowerCase(); if (text.includes('launch workflow')) { const workflowName = text.replace('launch workflow', '').trim(); const workflow = await launchTallyfyWorkflow(workflowName); await context.sendActivity({ attachments: [CardFactory.adaptiveCard(createWorkflowCard(workflow))] }); } if (text.includes('my tasks')) { const tasks = await getTallyfyTasks(context.activity.from.aadObjectId); await context.sendActivity({ attachments: [CardFactory.adaptiveCard(createTaskListCard(tasks))] }); } await next(); }); } async handleTeamsTaskSubmit(context, taskModuleRequest) { const { action, taskId } = taskModuleRequest.data; if (action === 'complete') { await completeTallyfyTask(taskId); return { task: { type: 'message', value: 'Task marked complete!' }}; } } } ``` ## Authentication Teams integration uses Azure AD OAuth 2.0. Configure in Azure portal: 1. Register app in Azure AD 2. Add Microsoft Graph API permissions 3. Configure redirect URIs for your integration 4. Use client credentials flow for server-to-server calls ```javascript const { ConfidentialClientApplication } = require('@azure/msal-node'); const msalConfig = { auth: { clientId: process.env.AZURE_CLIENT_ID, clientSecret: process.env.AZURE_CLIENT_SECRET, authority: `https://login.microsoftonline.com/${process.env.AZURE_TENANT_ID}` } }; const cca = new ConfidentialClientApplication(msalConfig); const getGraphToken = async () => { const result = await cca.acquireTokenByClientCredential({ scopes: ['https://graph.microsoft.com/.default'] }); return result.accessToken; }; ``` ## iPaaS alternatives If custom development is not available: - **Power Automate**: Microsoft's native automation platform - **Zapier**: Pre-built Teams triggers and actions - **Workato**: Enterprise automation with Teams connector - **Make**: Visual workflow builder with Teams integration ### Workday - **[Workday technical integration](https://tallyfy.com/products/pro/integrations/vendors/workday/technical/)**: Technical implementation details for connecting Workday with Tallyfy including API integration examples, webhook handling, data mapping, and authentication configuration for enterprise deployments. ## Integration options Workday provides several integration methods. Choose based on your technical requirements and partnership status. ### Workday Integration Cloud (XML) Use Workday's native integration platform for scheduled data sync: ```xml https://api.tallyfy.com/v1/workflows ``` ### REST API integration For approved partners with Workday REST API access: ```javascript const processWorkdayEvent = async (event) => { if (event.type === 'WORKER_HIRED') { const worker = await workdayAPI.getWorker(event.workerId); const workflow = await fetch('https://api.tallyfy.com/v1/workflows', { method: 'POST', headers: { 'Authorization': 'Bearer YOUR_TALLYFY_KEY', 'Content-Type': 'application/json' }, body: JSON.stringify({ template_id: 'enterprise_onboarding', data: { employee_id: worker.employeeID, name: worker.legalName, email: worker.workEmail, cost_center: worker.costCenter, location: worker.primaryWorkLocation, job_profile: worker.jobProfile, manager: worker.manager } }) }); return workflow.json(); } }; ``` ## Data mapping Common Workday fields to map to Tallyfy workflow variables: | Workday Field | Tallyfy Variable | Description | |---------------|------------------|-------------| | `employeeID` | `employee_id` | Unique employee identifier | | `legalName` | `full_name` | Employee full name | | `workEmail` | `email` | Work email address | | `costCenter` | `cost_center` | Cost center code | | `businessUnit` | `business_unit` | Business unit name | | `primaryWorkLocation` | `location` | Office location | | `jobProfile` | `job_title` | Job title/role | | `manager` | `manager_name` | Direct manager | | `workerType` | `employee_type` | Full-time, contractor, etc. | ## Authentication Workday uses OAuth 2.0 with JWT for API authentication. Store credentials securely and never expose them in client-side code. ## iPaaS alternatives If direct API access is unavailable, use integration platforms: - **Celigo**: NetSuite-native with Workday connectors - **Workato**: Enterprise automation recipes - **MuleSoft**: Anypoint Platform connectors - **Boomi**: Dell Boomi AtomSphere ### Miscellaneous - **[About Tallyfy](https://tallyfy.com/products/pro/miscellaneous/about-tallyfy/)**: Tallyfy has established itself as a trustworthy workflow platform through nine years of profitable independent operation with full data ownership and export capabilities along with API-first integration architecture and a commitment to remaining privately held without venture capital pressure while maintaining SOC 2 Type 2 compliance and transparent pricing practices. ## Why you can trust Tallyfy with your workflows ### Track record of stability Tallyfy has operated continuously since 2015 as a profitable, independent company. Nine years in SaaS isn't just survival - it's proof we know how to build something that lasts. While competitors chase venture capital and burn through funding, we've stayed focused on building a sustainable business that serves customers, not investors. ### Your data belongs to you We believe in complete data ownership and portability. You can [export all your process data to CSV](/products/pro/tracking-and-tasks/processes/how-can-i-export-tallyfy-processes-to-csv/) anytime - every task, form field, comment, and timestamp. Our [REST API](/products/pro/integrations/open-api/) provides full programmatic access to extract, backup, or migrate your data. We even maintain [open source migration scripts](https://github.com/tallyfy/migrator)[1] to help you move data in from 15+ other platforms. Your workflows are yours - we just help you run them better. ### Integration-first architecture Tallyfy works with what you already have. Our API-first design means every feature in our interface is available through the [REST API](/products/pro/integrations/open-api/). We support [middleware platforms](/products/pro/integrations/middleware/) like Zapier, Make.com, Power Automate, and n8n for code-free integrations. Check our [GitHub repositories](https://github.com/tallyfy)[2] for integration tools, API support, and migration scripts - all open source. We don't lock you in; we connect you out. ### Built to stay independent Here's what sets us apart: we have zero intention of selling Tallyfy. No exit strategy. No flip. The founders built this company to run it, not to cash out. As an independent company without venture capital: - Customer needs drive every product decision - No pressure to sell or exit for investor returns - Focus on sustainable growth over growth-at-all-costs - Direct accountability to users, not a board of investors We've watched too many good products get acquired and ruined. That won't happen here. ### Security you can verify Tallyfy maintains: - [SOC 2 Type 2 compliance](/products/pro/compliance/) with independent auditing - [BIMI compliance](/products/pro/compliance/bimi-compliance/) for email authentication - [HSTS compliance](/products/pro/compliance/hsts-compliance/) for encrypted connections - Complete audit trails for every action - Enterprise-grade encryption at rest and in transit ### Fair, transparent pricing Our [Fair Price Guarantee program](/products/pro/pricing/) ensures consistent pricing regardless of geographic location. No surprise price hikes, no bait-and-switch tactics, no "call us for enterprise pricing" games. The price you see is the price you pay. Learn more at our [company page](https://tallyfy.com/about-tallyfy/)[3]. ### Independence vs. venture capital Industry statistics on venture-backed companies: - 75% of VC-backed companies never return cash to investors[4] (Harvard Business School) - 35% of Series A startups fail before Series B[5] - VC exits to private equity often lead to higher prices and declining service[6] - Series A closures have increased significantly year over year[7] - **[Tallyfy on mobile devices](https://tallyfy.com/products/pro/miscellaneous/does-tallyfy-work-on-all-devices/)**: Tallyfy functions on all devices through responsive web design that automatically adapts to different screen sizes without requiring separate app installations or downloads. ## Device and platform compatibility Tallyfy works on any device with a modern web browser through responsive web design. This universal compatibility eliminates device-specific restrictions and complex setup requirements. ### Screen size adaptation The Tallyfy platform automatically adjusts its interface layout to accommodate various screen sizes including desktop computers, tablets, and smartphones. This responsive design ensures optimal user experience across all devices without requiring separate app downloads or installation procedures. ### Mobile and remote access Mobile accessibility enables productive workflow management while traveling or working remotely. Users maintain complete functionality regardless of device choice, ensuring uninterrupted business process execution from any location. ![](https://screenshots.tallyfy.com/Tallyfy-mobile-dashboard.png) ### No separate mobile app needed Currently, Tallyfy doesn't provide a separate mobile app for download from app stores because the responsive website functions exceptionally well on mobile devices. This web-based approach ensures immediate access without installation delays, storage requirements, or app store dependencies. ### Desktop app for enhanced productivity For users who want native desktop integration, Tallyfy offers a desktop app for macOS, Windows, and Linux. The desktop app provides: - **Native notifications** that work even when your browser is closed - **System tray integration** for quick access - **Seamless OAuth login** using your existing Chrome browser sessions - **Auto-updates** to always have the latest version [Learn how to install the Tallyfy desktop app](/products/pro/miscellaneous/how-can-i-install-the-tallyfy-desktop-app/) - **[Glossary](https://tallyfy.com/products/pro/miscellaneous/glossary/)**: This glossary defines essential Tallyfy workflow platform terminology from Administrator roles and API integrations to webhooks and workflow automation enabling teams to communicate precisely about business process management and digital transformation initiatives. ## Key terms for Tallyfy This glossary defines essential workflow platform terminology used throughout Tallyfy. Understanding these terms enables more effective platform navigation and workflow management success. ### A [**Administrator**](/products/pro/documenting/members/) Administrator users possess full organizational access permissions including template creation, editing capabilities, settings management, and complete organization administration rights. [**Agentic Workflow**](/products/pro/integrations/computer-ai-agents/rpa-vs-computer-use-agents/) Agentic workflows use AI agents that autonomously plan, execute, and dynamically adapt action sequences to achieve high-level business goals. This approach contrasts with traditional linear, predefined workflow scripts. [**Analytics**](/products/pro/integrations/analytics/) Tallyfy Analytics provides full business intelligence tools and detailed reports delivering insights into process performance metrics, task completion times, and workflow efficiency statistics. [**API (Application Programming Interface)**](/products/pro/integrations/open-api/) Tallyfy's API enables external software systems to interact programmatically with workflow platform functionality through standardized integration protocols. [**Approve/Reject Task**](/products/pro/tracking-and-tasks/tasks/what-types-of-tasks-can-i-create-with-tallyfy/) Approve/Reject tasks represent specific workflow decision points requiring assignees to either approve or reject submitted items. These tasks commonly serve as crucial workflow gateways. [**Assignee**](/products/pro/documenting/templates/edit-templates/understanding-assignment-types/) Task assignees are designated individuals responsible for completing specific workflow tasks within defined timeframes and quality standards. [**Automation Rule**](/products/pro/documenting/templates/automations/) Automation rules implement logical "if-this-then-that" conditions enabling processes to adapt automatically based on specific triggers, data conditions, or workflow events. [**Auto-Send Email**](/products/pro/tracking-and-tasks/tasks/what-types-of-tasks-can-i-create-with-tallyfy/) Auto-Send Email tasks automatically dispatch predefined email messages when workflow execution reaches specific process steps, eliminating manual email review requirements. ### B [**Blueprint**](/products/pro/integrations/open-api/) Blueprint represents Tallyfy's API terminology for workflow templates, providing programmatic access to template structures and configurations. [**BPMN (Business Process Model and Notation)**](/products/pro/documenting/templates/how-to-convert-bpmn-patterns-into-tallyfy-templates/) BPMN provides standardized graphical notation for representing business processes within workflow diagrams. BPMN diagrams can be systematically converted into executable Tallyfy templates. [**Board View**](/products/pro/tracking-and-tasks/tracker-view/how-to-switch-between-board-and-table-formats-in-tallyfy-tracker/) Board View displays processes as visual cards within Tallyfy's Tracker interface, enabling intuitive Kanban-style workflow visualization and drag-and-drop process management. ### C [**Checklist Field**](/products/pro/tracking-and-tasks/tasks/how-to-create-and-use-subtasks/) Checklist Fields enable subtask creation within parent tasks, featuring configurable completion rules and granular progress tracking capabilities. [**Computer AI Agent**](/products/pro/integrations/computer-ai-agents/) Computer AI Agents represent sophisticated software systems capable of perceiving digital environments, making autonomous decisions, and executing complex tasks. These agents automate intricate web and application interactions previously requiring human intervention. [**Compliance**](/products/pro/compliance/) Tallyfy's compliance features assist organizations in meeting regulatory requirements through complete documentation systems, detailed audit trails, and standardized process controls. [**Conditional Logic**](/products/pro/documenting/templates/automations/) Conditional logic rules determine workflow progression paths based on specific data conditions, user responses, or system states. These "if-this-then-that" rules enable dynamic workflow adaptation. [**CSV Export**](/products/pro/tracking-and-tasks/processes/how-can-i-export-tallyfy-processes-to-csv/) CSV Export functionality enables process data extraction to comma-separated values file format, facilitating advanced analysis within spreadsheet applications and business intelligence tools. [**Custom View**](/products/pro/tracking-and-tasks/tracker-view/how-to-create-custom-views-in-tallyfy/) Custom Views provide personalized Tracker configurations that filter and display processes according to user-defined criteria, improving workflow visibility and management efficiency. ### D [**Dashboard**](/products/pro/) The central interface displaying critical information including recent processes, assigned tasks, system announcements, and workflow performance metrics. [**Deadline**](/products/pro/documenting/templates/edit-templates/) The specific date and time by which a task must be **completed** to maintain workflow schedule adherence. Different from start time, which indicates when work should begin. [**Document Template**](/products/pro/documenting/documents/) A reusable document structure with fixed content elements and customizable fields for creating standardized business documents. ### E [**Email Draft**](/products/pro/tracking-and-tasks/tasks/what-types-of-tasks-can-i-create-with-tallyfy/) A specialized task type that prepares email messages for human review and approval before automated sending. [**Expiring Step**](/products/pro/tracking-and-tasks/tasks/what-types-of-tasks-can-i-create-with-tallyfy/) A time-sensitive task that automatically completes after a predefined time period, ensuring workflow progression continues. ### F [**Field**](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) A data entry element within forms where users input specific information types including text, numbers, dates, or file uploads. [**Folder**](/products/pro/documenting/templates/organize-templates-into-folders/) An organizational structure for grouping templates or tasks into logical categories for enhanced navigation and management efficiency. [**Form**](/products/pro/tutorials/how-to/build-effective-forms/) A structured collection of fields designed to systematically gather specific information from users or external collaborators. ### G [**Guest**](/products/pro/documenting/guests/) An external collaborator from outside your organization who can participate in specific processes without requiring a Tallyfy license or account creation. ### I [**Integration**](/products/pro/integrations/) A bidirectional connection between Tallyfy and external software systems enabling automated data exchange and action triggering across platforms. [**Interactive Email Actions**](/products/pro/integrations/interactive-email-actions/) A streamlined feature allowing email recipients to directly approve, reject, or complete other task actions from email notifications without requiring Tallyfy login. [**Intelligent Process Automation (IPA)**](/products/pro/integrations/computer-ai-agents/rpa-vs-computer-use-agents/) An automation approach combining human tasks, RPA bots, and Computer AI Agents within unified, intelligent workflow processes. ### J [**Job Title Assignment**](/products/pro/documenting/templates/edit-templates/understanding-assignment-types/) Assigning tasks to a role instead of a specific person, allowing flexibility in who completes the task. ### K [**Kick-off Form**](/products/pro/launching/triggers/kick-off-forms/) The initial form that collects information when launching a process. ### L [**Launch**](/products/pro/launching/) The action of starting a new process instance from a template. [**Light User**](/products/pro/documenting/members/) A user role with limited capabilities who can complete tasks but cannot create or edit templates. ### M [**Magic Link**](/products/pro/launching/triggers/magic-links/) A special URL that allows processes to be launched by anyone (even without a Tallyfy account) who has access to the link. [**Member**](/products/pro/documenting/members/) A registered user within your Tallyfy organization with a specific role. [**Middleware**](/products/pro/integrations/middleware/) A custom code layer that can handle complex integrations between Tallyfy and other systems. ### O [**OAuth**](/products/pro/integrations/open-api/oauth-authorization-flow/) An authorization protocol that allows third-party applications to access Tallyfy's API on behalf of users without sharing password credentials. [**Organization**](/products/pro/settings/org-settings/) The top-level account in Tallyfy that contains all members, templates, and processes. [**Organization ID**](/products/pro/miscellaneous/how-to-find-your-tallyfy-ids/) A unique identifier for your Tallyfy account, often needed for support or integration purposes. ### P [**Personal Settings**](/products/pro/settings/personal-settings/) User-specific configurations like notification preferences and language settings. [**Power Tools**](/products/pro/documenting/templates/how-can-power-tools-enhance-my-tallyfy-experience/) Advanced template features that enable more sophisticated automation and enhanced functionality in Tallyfy. [**Process**](/products/pro/tracking-and-tasks/processes/) A running instance of a template that tracks the execution of a specific workflow. [**Process Lifecycle**](/products/pro/tracking-and-tasks/processes/process-lifecycle-management/) The complete sequence of phases a process goes through, from creation and launch to execution, monitoring, and completion. [**Process Notes**](/products/pro/tracking-and-tasks/processes/edit-processes/how-to-add-process-notes/) Additional contextual information that can be added to a process for improved communication and documentation. [**Procedure Template**](/products/pro/documenting/templates/) A reusable definition of a workflow that outlines the steps, assignments, and rules for a business process. ### R [**Rich Text Editor**](/products/pro/tracking-and-tasks/tasks/edit-task/how-can-i-use-tallyfys-rich-text-editor-for-tasks/) The text formatting tool in Tallyfy that allows for styling text, adding links, embedding images, and more in task descriptions and fields. [**RPA (Robotic Process Automation)**](/products/pro/integrations/computer-ai-agents/rpa-vs-computer-use-agents/) Technology that uses software "bots" to mimic repetitive, rule-based human actions on digital systems, following pre-programmed scripts. [**Role**](/products/pro/documenting/members/) Defines what actions a user can perform in Tallyfy (Administrator, Standard, or Light). ### S [**Single Sign-On (SSO)**](/products/pro/integrations/authentication/) Authentication method allowing users to access Tallyfy using existing corporate credentials. [**Snippet**](/products/pro/documenting/templates/snippets/) Reusable blocks of content that can be inserted into templates. [**Standard User**](/products/pro/documenting/members/) A user role that can create and edit templates but cannot manage organization-wide settings. [**Start Time**](/products/pro/documenting/templates/edit-templates/edit-steps/) The suggested date and time when work should **begin** on a task. Unlike deadlines (which determine when work must be complete), start times provide scheduling guidance but are not enforced. [**Step**](/products/pro/documenting/templates/) A component in a template that becomes a task when a process is launched. [**Subtask**](/products/pro/tracking-and-tasks/tasks/how-to-create-and-use-subtasks/) A smaller action item within a task, typically created using a checklist field, allowing for granular tracking of task components. ### T [**Table View**](/products/pro/tracking-and-tasks/tracker-view/how-to-switch-between-board-and-table-formats-in-tallyfy-tracker/) A display format in the Tracker view that shows processes in a spreadsheet-like layout with rows and columns. **Tags** Keywords or labels that can be added to templates and processes for categorization and filtering. [**Task**](/products/pro/tracking-and-tasks/tasks/) A single unit of work within a process that is assigned to someone for completion. [**Tasks View**](/products/pro/tracking-and-tasks/tasks-view/) The interface showing all tasks assigned to you or others across all processes. [**Template**](/products/pro/documenting/templates/) A reusable blueprint that defines a standardized process or document. [**Template Import**](/products/pro/documenting/templates/import-feature/) A feature that allows users to import templates from CSV files or other sources to quickly create new templates. [**Template Owner**](/products/pro/documenting/templates/) The person responsible for maintaining and updating a specific template. [**Trackable AI**](/products/pro/integrations/computer-ai-agents/) Tallyfy's approach to AI integration that ensures all automated actions are visible, accountable, and continuously improvable. [**Tracker View**](/products/pro/tracking-and-tasks/tracker-view/) The interface showing a bird's-eye view of process progress at a per-process level. [**Translation**](/products/pro/miscellaneous/how-can-i-translate-content-in-tallyfy/) Features for displaying Tallyfy's interface and content in different languages. ### U [**Universal Search**](/products/pro/miscellaneous/how-to-use-tallyfys-universal-search-function/) The search function that finds content across all areas of Tallyfy. ### V [**Variable**](/products/pro/documenting/templates/variables/) A placeholder that can be used in templates and automatically filled with specific information during process execution. **Version Control** The system automatically tracks changes made to templates, allowing you to view previous versions. ### W [**Webhook**](/products/pro/integrations/webhooks/) A method for Tallyfy to send real-time notifications to other systems when specific events occur. [**Workflow**](/products/pro/documenting/templates/) A sequence of tasks that represent a business process, typically implemented as a procedure template in Tallyfy. - **[Become a Tallyfy partner](https://tallyfy.com/products/pro/miscellaneous/how-can-i-become-a-tallyfy-partner/)**: Tallyfy offers partnership opportunities for consultants agencies and software companies with benefits including referral rewards dedicated dashboards unbilled domain access for client accounts joint marketing and priority support requiring partners to maintain active accounts follow guidelines and actively promote services through an application process at their partner website. ## Becoming a Tallyfy partner Tallyfy creates strategic partnerships with consultants, agencies, and software companies seeking to use Tallyfy for helping clients effectively manage complex workflows and optimize business processes. ### What partnership types does Tallyfy provide? - **Solution Partners**: Consultants and agencies who implement Tallyfy solutions for their clients - **Technology Partners**: Software companies who integrate their products with Tallyfy's platform - **Referral Partners**: Organizations who refer qualified prospects to Tallyfy ### What benefits do Tallyfy partners receive? - Earn **partnership benefits** for successfully referred clients - Option to **provide value-added services** to clients - Access a **dedicated partner dashboard** to track performance metrics - **Unbilled Domain Access**: Your team accesses client accounts without increasing the client's account costs (detailed below) - Opportunities for **joint marketing initiatives** and strategic collaboration - **Priority technical support** for partner-related issues and implementations - Access to **complete partner resources and training materials** for successful implementations - Offer **expanded consulting services** by using Tallyfy metrics to continuously improve client processes, delivering measurable long-term ROI ### Unbilled Domains for partners When your team helps clients implement Tallyfy, you shouldn't increase their account costs just for your team's access. Unbilled Domains elegantly solves this challenge: 1. The client adds your company's email domain (e.g., `yourconsultancy.com`) to their Tallyfy account exclusion list 2. Anyone accessing the client's Tallyfy account with an email address from `@yourconsultancy.com` is automatically marked as "Unbilled" 3. When Tallyfy calculates account usage, it counts only the client's employees, excluding all "Unbilled" partner members **Practical example:** - ClientCorp adds `partner.com` to their account exclusion list - ClientCorp has 15 employees (`@clientcorp.com`) and 5 consultants (`@partner.com`) using Tallyfy - ClientCorp's account counts only their 15 employees, while consultants access the system at no additional impact This powerful feature enables complete partner collaboration within client accounts without increasing the client's operational expenses. ### What commitments are required for Tallyfy partners? To ensure successful partnerships, Tallyfy partners commit to the following program requirements: - **Active Tallyfy Account**: Partners must maintain an active Tallyfy account serving as a demonstration environment for potential customers - **Agreement Compliance**: Partners must adhere to terms outlined in the Tallyfy Referral Agreement, Trademark Usage Guidelines, Customer Terms of Service, and Privacy Policy - **Active Promotion**: Partners are expected to actively promote Tallyfy services through their websites and established marketing channels - **Prohibited Activities**: Partners cannot associate Tallyfy marketing materials with unlawful, harmful, defamatory, obscene, offensive, or discriminatory content. Sending unsolicited bulk messages (spam) to promote Tallyfy is strictly prohibited - **Trademark Usage**: Partners must use Tallyfy trademarks, logos, and marketing materials only as specified in Trademark Usage Guidelines and official instructions ### Applying for partnership ### More information For questions about the partnership program, contact our team directly at [partner@tallyfy.com](mailto:partner@tallyfy.com) for detailed information and guidance. - **[Generate a HAR file for troubleshooting](https://tallyfy.com/products/pro/miscellaneous/how-can-i-generate-a-har-file-for-troubleshooting/)**: HAR files are comprehensive technical logs that capture complete browser network activity including requests responses and load times to help troubleshoot Tallyfy issues across different browsers like Chrome Firefox Edge and Safari by recording network activity and exporting the data for support analysis. ## Creating and sharing HAR files for support A HAR (HTTP Archive) file serves as a technical log used for Tallyfy troubleshooting, diagnosing website speed issues, caching problems, and intermittent problems that are difficult to reproduce. This detailed file captures complete information about your browser's network activity, including all requests, responses, and precise load times. ### Generating HAR files in different browsers #### Chrome #### Firefox #### Microsoft Edge #### Safari #### Internet Explorer Internet Explorer does not support HAR file generation directly. We recommend using modern browsers like Chrome, Firefox, or Edge for HAR file creation. If you must use Internet Explorer, follow Microsoft's developer instructions for capturing network traffic (typically resulting in XML or CSV files) and provide those files instead. ### Sharing HAR files with support Always attach the generated HAR file directly to your support ticket or email for effective troubleshooting assistance. HAR files contain detailed network information that helps support teams identify and resolve issues quickly. - **[Install the Tallyfy desktop app](https://tallyfy.com/products/pro/miscellaneous/how-can-i-install-the-tallyfy-desktop-app/)**: The Tallyfy desktop app delivers native desktop functionality for macOS Windows and Linux users including system notifications tray integration and automatic Chrome login import while requiring users to bypass security warnings during installation since the app lacks official notarization. ## How to install the Tallyfy desktop app The Tallyfy desktop app provides a native experience on macOS, Windows, and Linux. It wraps the same Tallyfy web application you already use - so all features work exactly the same - but adds desktop-specific benefits like native notifications and system tray integration. ### Why use the desktop app? The desktop app offers several advantages over using Tallyfy in a browser: - **Native notifications** - Get task reminders even when your browser is closed - **System tray** - Quick access to Tallyfy from your menubar or taskbar - **Seamless login** - The app can import your existing Google or Microsoft login from Chrome, so you may already be logged in - **Auto-updates** - The app automatically updates when new versions are available - **Dedicated window** - Keep Tallyfy separate from your browser tabs ### Download and install Download the installer for your platform: | Platform | Download | |----------|----------| | **macOS (Apple Silicon)** | [Tallyfy-1.0.0-arm64.dmg](https://desktop.tallyfy.com/releases/latest/Tallyfy-1.0.0-arm64.dmg) | | **macOS (Intel)** | [Tallyfy-1.0.0.dmg](https://desktop.tallyfy.com/releases/latest/Tallyfy-1.0.0.dmg) | | **Windows** | [Tallyfy-Setup-1.0.0.exe](https://desktop.tallyfy.com/releases/latest/Tallyfy-Setup-1.0.0.exe) | #### macOS 1. Download the `.dmg` file for your Mac (Intel or Apple Silicon) 2. Open the DMG file and drag the Tallyfy icon to your Applications folder 3. On first launch, you may need to right-click the app and select **Open** to bypass Gatekeeper (since the app is not yet notarized) 4. If you see a "damaged" error, open Terminal and run: `xattr -cr /Applications/Tallyfy.app` #### Windows 1. Download the `.exe` installer 2. Run the installer and follow the prompts 3. On first launch, Windows SmartScreen may show a warning - click **More info** then **Run anyway** 4. The app will appear in your Start menu #### Linux Linux builds are not currently available. Please contact support if you need Linux support. ### System requirements | Platform | Minimum Version | |----------|-----------------| | macOS | 12.0 (Monterey) or later | | Windows | Windows 10 or later | | Linux | Ubuntu 22.04 or equivalent | ### Signing in When you launch the Tallyfy desktop app for the first time, it automatically tries to import your existing login from Chrome. If you're already signed into Google or Microsoft in Chrome, you may be logged into Tallyfy automatically. If automatic login doesn't work: 1. Click any sign-in option (Google, Microsoft, email) 2. Complete the authentication flow - it opens in your system browser 3. Return to the desktop app after signing in ### Troubleshooting **macOS shows "app is damaged" error** This happens because the app isn't notarized yet. Fix it by running: ```bash xattr -cr /Applications/Tallyfy.app ``` **Windows SmartScreen warning** Click **More info** then **Run anyway**. This warning appears because the app doesn't have an extended validation certificate yet. **Not logged in automatically** The Chrome cookie import requires access to Chrome's Safe Storage. On macOS, you may be prompted to allow Keychain access - click **Allow** to enable automatic login. **App won't start** Ensure you have the correct version for your system architecture (Intel vs Apple Silicon on Mac, 64-bit vs 32-bit on Windows). - **[Translate content](https://tallyfy.com/products/pro/miscellaneous/how-can-i-translate-content-in-tallyfy/)**: Tallyfy provides interface language customization and Azure AI-powered content translation capabilities to support multilingual teams with administrators able to configure Microsoft Azure Cognitive Services integration for real-time translation of user-generated content across over 100 languages. ## Translation options in Tallyfy Tallyfy offers two translation features: 1. **Interface Language**: Change the display language for menus, buttons, and system text 2. **Content Translation**: Translate user-generated text using Microsoft Azure AI (requires administrator setup) See [global workplace language requirements](/products/pro/integrations/azure-translation/global-workplace-language-requirements/) to understand which countries mandate or recommend translation of process content like SOPs and employee handbooks. ### Change interface language ### Available interface languages Tallyfy supports English, Spanish, French, German, Chinese, Japanese, and others. ### Administrator setup for content translation Content translation uses Microsoft Azure Cognitive Services. Supports over 100 languages. #### Requirements * Active Microsoft Azure account with translation services enabled * API Key and Region/Location credentials for the Azure Translator service * Administrator-level access within your Tallyfy organization #### Configuration steps *(See the [Azure setup guide](/products/pro/integrations/azure-translation/how-to-set-up-azure-cognitive-ai-integration/) for detailed Azure configuration.)* ### User access after setup Once configured, users select their language via the globe icon. ### Using content translation :::note[Translation limitations] Real-time translation works best with standard business text. Highly technical terms, slang, or specific industry jargon might not translate accurately. **RTL (Right-to-Left) support**: Tallyfy currently does not support RTL languages like Arabic or Hebrew for interface display. While content can be translated to these languages, the layout remains left-to-right. Full RTL support is under consideration for future development. ::: - **[See product updates](https://tallyfy.com/products/pro/miscellaneous/how-can-i-stay-updated-with-tallyfys-latest-features/)**: Tallyfy users can stay updated with the latest features by accessing the Latest Updates section through their profile menu within the platform or by visiting the comprehensive changelog page at tallyfy.com/changelog. ## Staying updated with Tallyfy features Tallyfy regularly releases new features and improvements. You can stay informed about these updates through two convenient methods: ### Viewing updates within Tallyfy **Inside the Tallyfy Platform**: Click your name in the top-right corner, then select **Latest Updates** from the dropdown menu to see recent Tallyfy platform improvements and new features. ### Accessing the complete changelog **On the Tallyfy Website**: Navigate directly to the complete changelog page at [tallyfy.com/changelog](https://tallyfy.com/changelog/) to view detailed release notes and feature announcements. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-check-updates.png) - **[File storage and security](https://tallyfy.com/products/pro/miscellaneous/how-does-file-storage-work-in-tallyfy/)**: Tallyfy provides secure file storage through Amazon S3 with plan-specific limits ranging from 5GB total to 25GB per member while also supporting external file linking from cloud services like Dropbox and SharePoint that don't count toward storage quotas. ## File storage in Tallyfy Tallyfy stores uploaded files in Amazon S3 with plan-specific storage limits. You can also link to external files from cloud storage services without using your Tallyfy storage quota. ### Storage system Tallyfy enables file uploads to steps, [tasks](/products/pro/tracking-and-tasks/tasks/), forms, and comments. All uploaded files are stored securely in Amazon S3 buckets with enterprise-grade [security](/products/pro/compliance/) measures and full data protection. #### Storage limits by plan - All uploaded PDFs, documents, images, screenshots, audio, and video files count towards your subscription's storage limit - Default storage location resides in the US West region within AWS data centers in Oregon - Storage limits vary by subscription plan: - **Docs plan**: 5GB total organizational storage - **Basic plan**: 5GB per [member](/products/pro/documenting/members/) - **Pro plan**: 25GB per member - **Enterprise plan**: Custom storage limits based on organizational requirements #### Storage considerations - File links shared through external apps like Box, Dropbox, Google Drive, or OneDrive do **not** count towards your Tallyfy storage limit - When approaching storage limits, Tallyfy provides notifications with these options: - Delete outdated or unnecessary files from Tallyfy - Upgrade your subscription plan for additional storage capacity - Future "bring your own storage" options (contact support for availability updates) ### Security and compliance For complete IT, [compliance](/products/pro/compliance/), and [security](/products/pro/compliance/) details about file storage, visit our [compliance and security page](https://tallyfy.com/legal/compliance-security/). Data export capabilities vary by subscription plan; contact support for specific feature availability. ### Recommended approach Tallyfy focuses on workflow management. Use your existing cloud storage (Dropbox, Box, Google Drive, SharePoint) for file management and link those files in Tallyfy workflows. Learn how to implement this approach with [document management integration](mdc:products/pro/integrations/document-management/). ### Tallyfy storage vs external systems #### When to use Tallyfy file storage: - **Workflow-centric files**: Documents that are integral to the process flow and need to be directly accessible within tasks - **Simple file management needs**: When you don't require advanced document management features like version control or redlining - **Unified workflow tracking**: Files that need to be tracked as part of the overall process audit trail - **Smaller file sizes**: Files under the 150MB upload limit that don't require specialized hosting #### When to use external storage (SharePoint, etc.): - **Document management requirements**: When you need features like redlining, version control, or collaborative editing - **Regulatory compliance**: Organizations with specific document storage requirements (HIPAA, life sciences, etc.) - **Large file handling**: Videos or large files exceeding the 150MB limit - **Existing document governance**: When you have established DMS policies or approved file systems - **Advanced file features**: Word documents requiring tracked changes or specialized document workflows #### Hybrid approaches work best: Many organizations successfully combine both approaches: - **Draft documents**: Start with external storage links for collaborative work - **Final documents**: Upload final PDFs to Tallyfy for process completion and archival - **Process-specific files**: Use Tallyfy for workflow-critical documents, external storage for supporting materials - **Security-sensitive files**: Link to internal file servers for sensitive documents while maintaining workflow tracking ### Technical specifications #### Tallyfy Storage Specifications: - **Upload limit**: 150MB per file (larger files should use external hosting like Vimeo for videos) - **Storage allocation**: Plan-specific limits from 5GB total to 25GB per member - **Security**: Enterprise-grade Amazon S3 storage with full data protection - **Integration**: Files directly accessible within workflow tasks and processes #### External Storage Integration: - **File Request Integration**: Create unique [file request links](mdc:products/pro/integrations/document-management/file-request-links/) in your file-sharing system and share them within task descriptions. Tallyfy won't access files uploaded through these external requests - **Direct File Linking**: Upload files to your preferred storage platform, then copy specific file links and paste them into Tallyfy fields (including text [fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) or task descriptions) - **Link preservation**: External file links don't count toward your Tallyfy storage allocation ### Industry patterns #### Legal Services: - **Contract drafts**: SharePoint/Word for redlining and collaboration - **Final executed contracts**: Tallyfy upload for process completion and audit trail - **Client communications**: External file server links for sensitive documents #### Healthcare/Life Sciences: - **Patient files**: HIPAA-compliant external systems with links in Tallyfy - **Process documentation**: Tallyfy storage for workflow-critical files - **Regulatory submissions**: Approved DMS systems with reference links #### Financial Services: - **Customer documents**: Internal file servers for compliance - **Process attachments**: Tallyfy storage for workflow evidence - **Audit materials**: Document management systems with workflow tracking ### Sensitive data handling For sensitive information, use external file linking instead of direct uploads. See [how to protect sensitive data in Tallyfy](/products/pro/tracking-and-tasks/how-can-i-protect-sensitive-data-in-tallyfy/). - **[Login and session errors](https://tallyfy.com/products/pro/miscellaneous/how-to-connect-tallyfy-to-other-apps-using-private-browsing/)**: Private browsing mode resolves Tallyfy connection issues with external apps by providing a clean session without stored cookies cached data or saved credentials that can cause login conflicts and authorization problems. ## Using private browsing for app connections When connecting Tallyfy to external online tools (such as middleware, Slack, Google Drive, and other services), you may encounter login or authorization problems. These issues frequently stem from conflicting login information, cached data, or stored cookies in your regular browser session. Your browser's **private browsing mode** (also called Incognito, InPrivate, or Private Window) resolves these connection issues by providing a clean browsing session without stored cookies, cached data, or saved login credentials. ### When to use private browsing Use a private browsing window when you experience: - Login errors during connection authorization attempts - Repeated connection failures or timeout issues - Specific troubleshooting requests from Tallyfy support - Multiple account conflicts (e.g., different Google accounts) requiring clear account identification during connection setup ### Opening private browsing #### Chrome #### Firefox #### Microsoft Edge #### Safari (Mac) ### Additional troubleshooting steps If private browsing doesn't resolve the connection issue, try these alternative solutions: ### Contacting support If these steps don't resolve the problem, [contact Tallyfy support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/) with details about the apps you're connecting and any error messages. - **[Find your Tallyfy IDs](https://tallyfy.com/products/pro/miscellaneous/how-to-find-your-tallyfy-ids/)**: Every element in Tallyfy has unique identification numbers that are essential for support requests integrations and advanced workflow management with Organization IDs found in Settings Template IDs located in template export sections and Process IDs visible in browser URLs when viewing specific running processes. ## Finding your Tallyfy IDs Every element within Tallyfy possesses a unique identification number that serves various administrative and technical purposes across the platform. These unique IDs prove essential when contacting Tallyfy [support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/) for assistance, configuring specific [integrations](/products/pro/integrations/) including template imports, or performing advanced workflow management tasks requiring precise system identification. ### Locating the main Tallyfy IDs #### Finding your Organization ID * Navigate to **Settings** > **Organization**. * Your Organization ID is clearly displayed in this section. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-show-org-id.png) #### Finding a Template ID * Open the desired [template](/products/pro/documenting/templates/) in **Edit** mode. * Click the **Settings** (or **Config**) button in the top toolbar. * Navigate to the **Export** tab (sometimes labeled **Tools**). * The Template ID is displayed in this section, along with the Organization ID. #### Finding a Process ID * Open a specific running [process](/products/pro/tracking-and-tasks/processes/). * Examine the web address (URL) in your browser's address bar. * The URL follows this format: `https://go.tallyfy.com/[ORG_ID]/processes/[PROCESS_ID]`. * The segment after `/processes/` represents the unique ID for *that specific process instance*. - **[Universal search](https://tallyfy.com/products/pro/miscellaneous/how-to-use-tallyfys-universal-search-function/)**: Tallyfy's universal search function allows users to quickly locate any content across their workspace including templates running processes tasks and snippets by simply typing queries into the search bar which comprehensively indexes all content categories and displays results with contextual information and shareable links. ## Using Tallyfy's universal search Tallyfy's universal search bar delivers platform-wide search capabilities enabling rapid location of virtually any content including [templates](/products/pro/documenting/templates/), running [processes](/products/pro/tracking-and-tasks/processes/), specific [tasks](/products/pro/tracking-and-tasks/tasks/), and [snippets](/products/pro/documenting/templates/snippets/). This search feature streamlines workflow navigation by providing instant access to relevant content across your entire Tallyfy workspace. ### Performing a search Simply type what you're looking for into the Tallyfy universal search bar located at the top of your interface. ### What content can Universal Search find? Universal Search indexes multiple content categories and data fields throughout your Tallyfy organization: #### Template Search Coverage: * Template tags and categories * Template names and titles * Template descriptions and documentation * Step names within templates * Step descriptions and instructions #### Running Processes & Tasks Search Coverage: * Process tags and categorization * Process names and titles * Notes added to processes * Task names within processes * Task descriptions and instructions * Comments added to tasks within processes #### One-off Tasks Search Coverage: * One-off task names and titles * Comments added to standalone tasks #### Snippets Search Coverage: * Snippet titles and names * Snippet content and text ### Search results display The search results display all matching items with contextual information. When searching for templates organized in folders, results include the folder location path so you can easily navigate to the specific template. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-search-bar-results.png) ### Sharing search results To share a direct link to any search result (such as a template or process), click the **share icon** displayed next to that result. This action copies a direct link to your clipboard that you can send to team members or stakeholders. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-copy-search-result-link.png) - **[Differentiation](https://tallyfy.com/products/pro/miscellaneous/tallyfy-differentiation-guide/)**: Understand what makes Tallyfy different from other workflow and process management vendors in the market, including our unique approach to support, pricing, security, and innovation. ## What sets Tallyfy apart Tallyfy combines exceptional human support, transparent pricing, and enterprise-grade security - all while remaining profitable and sustainable for the long haul. Here's what makes us genuinely different. ### Free 1:1 support for life You get unlimited expert help at no extra cost. Forever. No support tiers, no premium fees - just real humans who actually help you succeed. Most vendors charge thousands for this level of support or hide behind ticket systems. We don't. Check our [customer reviews](https://www.capterra.com/p/143084/Tallyfy/) - they speak for themselves. ### Transparent pricing (no sales games) Our [pricing](/products/pro/pricing/) is right there on the website. Calculate your exact costs instantly. No "contact sales" buttons, no qualification calls, no surprise fees. Everything's included too - SSO, unlimited guests, full API access. Competitors charge $500-5000 extra just for SSO. We think that's ridiculous. ### Built to last We're profitable and self-funded. No VC pressure, no exit strategy, no "grow or die" mentality. Your processes and data are safe with a company that'll be here for decades, not just until the next funding round dries up. Learn more [about our philosophy](/products/pro/miscellaneous/about-tallyfy/). ### Your data, your way Everything you can do in Tallyfy, you can do through our [API](/products/pro/integrations/open-api/). Export all your data anytime. Connect to your [analytics tools](/products/pro/integrations/analytics/). No vendor lock-in whatsoever. We're also the first workflow platform with [MCP server integration](/products/pro/integrations/mcp-server/) - ready for AI agents from day one. ### Security beyond the checkbox Yes, we're [SOC 2 Type II certified](/products/pro/compliance/). But we're also: - **HSTS compliant** for maximum transport security (rare in our industry) - **BIMI compliant** for email authentication (we might be the only vendor with this) - **GDPR, HIPAA-ready** with all the right controls Most vendors stop at basic compliance. We go further because security isn't just a checkbox - it's fundamental. ### The practical difference What does this mean for you? **Lower costs**: Predictable pricing with everything included means no budget surprises. **Faster setup**: Expert support gets you productive in hours, not months. **Zero risk**: Our longevity and data portability eliminate vendor lock-in concerns. **Future-ready**: AI-native architecture means you won't need to re-platform later. **Peace of mind**: Enterprise security without enterprise complexity. ### Quick comparison **vs. Legacy BPM platforms**: We're 10x faster to implement, no coding required, and cost a fraction of the price. **vs. Project management tools**: We're built for repeatable processes, not one-off projects. Work flows automatically without manual coordination. **vs. No-code platforms**: You don't build on Tallyfy - you use it. No technical skills needed, proven templates included, integrated analytics built-in. - **[Tallyfy vs. Projects](https://tallyfy.com/products/pro/miscellaneous/understanding-tallyfy-vs-project-management/)**: Tallyfy handles predictable repeatable workflows like employee onboarding and invoice processing by standardizing processes through reusable templates with automated task assignment and continuous improvement while project management tools are designed for unique one-time endeavors where tasks differ each time. ## Tallyfy vs. project management software Tallyfy handles predictable, repeatable workflows while project management tools track unique, one-time projects. Use Tallyfy when you do the same process repeatedly - like onboarding employees or processing invoices - not for building a house or launching a product. The fundamental difference: Project management tools organize chaos. Tallyfy eliminates it by standardizing your repeating work. Think of it like cooking - successful restaurants don't recreate recipes from scratch each time. They document the recipe once, follow it consistently, and improve it based on feedback. That's exactly how successful companies handle their operations: they run processes, not projects. ## Why workflow management beats project management for repeating processes ### The project management trap Project management tools excel at unique endeavors - building a bridge, launching a campaign, developing software. Each project differs in tasks, timeline, and outcome. That's their strength. But here's the problem: Most business work isn't unique. It repeats. When you force repeating processes into project management tools: - **You recreate the wheel daily** - manually setting up the same tasks repeatedly - **Quality varies wildly** - each instance depends on who remembers what - **Knowledge walks out the door** - when Sarah leaves, her process expertise leaves too - **No improvement happens** - you can't optimize what you recreate from scratch ### The workflow management solution Tallyfy recognizes that most business operations are predictable patterns: - Employee onboarding follows the same 47 steps - Invoice processing has consistent approval rules - Client implementation uses standard phases - Equipment maintenance happens on schedules Instead of managing these as "projects," Tallyfy treats them as what they are - repeatable workflows that should run consistently every time. ## Key distinctions that matter ### Templates vs. projects **Project Management**: Start with a blank slate or copy last project - Risk: Missing steps, inconsistent execution - Reality: 3 hours recreating task lists **Tallyfy Workflows**: Launch from proven templates - Benefit: Perfect consistency, instant setup - Reality: 3 clicks to launch complete workflow ### Task assignment philosophy **Project Management**: Manually assign each task, every time - "Who should review this contract?" - "Is Bob available this week?" - Constant decision fatigue **Tallyfy Workflows**: Smart assignment rules - Assign to job titles: "Contract Reviewer" (system picks available person) - Conditional routing: High-value contracts → Senior Reviewer - Automatic workload balancing ### Improvement approach **Project Management**: Lessons learned after project ends - Post-mortems gather dust - Next project makes same mistakes - No systematic improvement **Tallyfy Workflows**: Continuous optimization - Update template → all future processes improve - Track metrics across instances - Real-time feedback loops ## Real-world example: Employee onboarding ### Using project management tools 1. HR creates new project: "Onboard Jane Smith" 2. Manually adds 40+ tasks from memory/checklist 3. Assigns each task individually 4. Hopes nothing falls through cracks 5. Repeats entire process for next hire **Result**: 2-3 hours setup, inevitable missed steps, stressed HR team ### Using Tallyfy 1. HR launches "Employee Onboarding" template 2. Enters new hire name and start date 3. System assigns all tasks based on rules 4. Automated reminders ensure completion 5. Template improves with each use **Result**: 3-minute setup, perfect consistency, happy employees ## "But I don't use processes in my business" Every business uses processes - you just might not call them that. Processes are like recipes in cooking - they ensure consistent results every time. If you've ever: - Onboarded a new customer or employee - Processed an invoice or payment - Handled a customer complaint - Prepared monthly reports - Conducted quality checks - Managed inventory restocking ...then you use processes. These are repeatable patterns that happen regularly in your business. The most successful companies don't just have processes - they document them, run them consistently, and continuously improve them. **Common processes every business has:** - **Sales**: Lead qualification → Quote creation → Contract negotiation → Deal closing - **Customer Service**: Ticket receipt → Issue investigation → Resolution → Follow-up - **Finance**: Invoice receipt → Approval routing → Payment processing → Recording - **HR**: Job posting → Candidate screening → Interviewing → Offer management - **Operations**: Order processing → Fulfillment → Shipping → Returns handling The difference isn't whether you have processes - it's whether they're documented, consistent, and trackable. Most businesses run these processes through email, memory, and sticky notes. Tallyfy just makes them visible and reliable. :::tip[Identifying your hidden processes] Look for work that: - Happens more than once - Involves multiple people - Has a "right way" to do it - Causes problems when done wrong - Takes time to teach new people These are all processes waiting to be optimized. ::: ## When to use each tool type ### Use project management tools for: - Building a new office (unique layout, timeline, requirements) - Launching a product (novel tasks, dependencies, milestones) - Organizing an event (specific venue, speakers, agenda) - Any work that's genuinely different each time ### Use Tallyfy for: - Processing any type of application or request - Onboarding employees, customers, or vendors - Compliance and audit procedures - Maintenance and inspection schedules - Customer service workflows - Any process you do more than twice ## The hybrid approach Many organizations need both: - **Tallyfy** for operational excellence (the repeating work) - **Project tools** for strategic initiatives (the unique work) Example: A construction company uses: - Project management for building unique structures - Tallyfy for permit applications, safety inspections, and equipment maintenance ## Breaking the project management habit ### Common objection: "But we're used to our project tool" Using project management for workflows is like using Excel for customer relationships - technically possible, but you're fighting the tool's design. Signs you need workflow management: - Creating similar projects repeatedly - Copying task lists between projects - Manually checking who did what - Losing track of standard procedures - Training takes forever because "it depends" ### The mindset shift Stop thinking "How do I manage this project?" Start thinking "How should this process work every time?" This shift from project to process thinking transforms operations: - From reactive to proactive - From chaotic to calm - From variable to reliable - From stressful to systematic ## Getting started with workflow thinking Successful companies follow a simple cycle: document it, run it, improve it. Here's how to apply this approach: 1. **Identify your repeating patterns** - What do you do weekly/monthly? - Which "projects" look suspiciously similar? - Where do mistakes repeat? 2. **Document the ideal process** (without huge documents and crazy flowcharts) - Not how it sometimes works - How it should work every time - Include decision points and rules - Keep it simple and followable 3. **Build once, run forever** - Create template in Tallyfy - Test and refine - Launch consistently - Remember: reading a process and doing it are totally different 4. **Measure and improve** (without worrying people will forget lessons learned) - Track completion times - Identify bottlenecks - Update template for everyone - Every improvement benefits all future runs ## Key takeaway Project management tools solve the wrong problem for repeating work. They help you organize chaos better. Tallyfy eliminates the chaos by turning repeating work into self-running workflows. Stop managing projects that aren't really projects. Start building workflows that run themselves. - **[Keyboard shortcuts](https://tallyfy.com/products/pro/miscellaneous/what-keyboard-shortcuts-can-i-use-in-tallyfy/)**: Tallyfy offers keyboard shortcuts for faster navigation including Ctrl+Option+T for creating tasks Ctrl+Option+P for launching processes Tab key for form field navigation and Spacebar for selecting options in forms and dropdowns. ## Keyboard shortcuts in Tallyfy Keyboard shortcuts enable faster navigation and task completion in Tallyfy by providing quick access to frequently used functions and workflow actions. ### General shortcuts These universal shortcuts function on most Tallyfy pages, except when actively using the template editor or viewing running process details. - **Create a one-off task**: Press `Ctrl + Option + T` (Mac) or `Ctrl + Alt + T` (Windows) to quickly create standalone tasks. - **Launch a process**: Press `Ctrl + Option + P` (Mac) or `Ctrl + Alt + P` (Windows) to open the Templates section for process launching. :::note[Key equivalents] The `Option` key on Mac keyboards corresponds to the `Alt` key on Windows keyboards. ::: ### Shortcuts for completing forms When completing [tasks](/products/pro/tracking-and-tasks/tasks/) with [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/), these shortcuts improve data entry efficiency: - **Tab key**: Navigate between form fields and move through options within dropdowns or radio button groups for sequential data entry. - **Spacebar**: Select or activate options including dropdown items, radio button selections, checkbox toggles, and file upload button activation. - **[Adoption](https://tallyfy.com/products/pro/miscellaneous/support/)**: Successful Tallyfy adoption requires involving team members early in process design selecting strategic initial processes ensuring leadership actively uses the platform enabling peer sharing implementing phased rollouts using automated onboarding templates and universal snippets while tracking both quantitative metrics like user activity and qualitative signals like proactive process suggestions. ## Getting support and helping your team adopt Tallyfy This section covers how to get help from Tallyfy and offers proven strategies to drive successful workflow adoption across your organization. ### Five essential strategies for workflow adoption Getting your team to successfully adopt Tallyfy requires thoughtful planning and execution. These battle-tested strategies help organizations achieve high adoption rates: #### 1. Involve people early and create ownership Talk to the people who'll actually use the processes day-to-day as you set them up. When team members participate in designing workflows, they develop a sense of ownership that naturally drives adoption. This approach transforms potential skeptics into champions. #### 2. Select your initial processes strategically Start with processes that: * Solve immediate, visible pain points * Save significant time within the first week * Affect multiple departments (to create cross-functional wins) * Are currently causing the most frustration or errors Avoid starting with complex, rarely-used processes - quick wins build momentum. #### 3. Leadership must lead by example Managers and executives need to actively use Tallyfy themselves - not just mandate it. When leaders visibly complete tasks, comment on processes, and reference Tallyfy in meetings, it signals that this isn't just another tool that will be abandoned. #### 4. Enable authentic peer sharing Encourage team members to share genuine experiences about how Tallyfy helps them. These organic testimonials carry more weight than any top-down communication. Create channels for users to: * Share time-saving discoveries * Celebrate process improvements * Help colleagues with tips and tricks #### 5. Plan your pilot and rollout systematically Don't just launch Tallyfy - architect a phased approach: * **Pilot phase**: Start with one enthusiastic team or department * **Expansion phase**: Roll out to adjacent teams who interact with the pilot group * **Organization-wide phase**: Scale based on proven success patterns * **Optimization phase**: Continuously refine based on usage data and feedback #### Automatically onboarding new team members A great way to help new hires learn Tallyfy and company processes is to automatically launch an onboarding template for them when they join. This approach works because it gives real-time guidance instead of relying on memory, which fails due to the forgetting curve. - **How**: In **Settings > Organization > Customization**, choose a template under **Auto-Launch Template for New Members** - **Benefit**: Every new [member](/products/pro/documenting/members/) is automatically assigned [tasks](/products/pro/tracking-and-tasks/tasks/) that guide them through learning Tallyfy and key company procedures Read more at [Auto-launch templates for new members](/products/pro/settings/org-settings/how-to-auto-launch-templates-for-new-members/). #### Using universal snippets for guidance Snippets are reusable text blocks. You can set up special "Universal Snippets" in **Settings > Organization > Personalization** to show messages in specific places: 1. **Guest View Snippets**: Show custom messages to external [guests](/products/pro/documenting/guests/) when they view tasks 2. **Member Homepage Snippets**: Display permanent messages on all members' Tallyfy homepages (excellent for announcements or important links) 3. **New Member Onboarding Snippets**: Show a one-time welcome message only to new members when they first log in 4. **Light Role Template Editing Snippets**: Show a message if a Light [role](/products/pro/documenting/members/how-do-i-manage-member-permissions-in-tallyfy/) user tries to edit a template (which they can't), explaining why Using these strategic snippets helps guide users through their Tallyfy experience effectively. #### Measuring workflow adoption success Track these concrete indicators to measure adoption: **Quantitative metrics**: - Active user percentage (target: 80%+ logging in weekly) - Process completion rates and times - Number of processes created by different team members - Reduction in process-related emails and meetings **Qualitative signals**: - Team members proactively suggesting processes to digitize - Decreased questions about "how to do X" - Positive mentions in team meetings - Requests for advanced features (shows engagement) **Early warning signs of low adoption**: - Same few people creating all processes - Processes started but not completed - Reverting to old methods despite having Tallyfy processes - No organic discussion about the tool #### What makes Tallyfy easier to adopt than other tools? Tallyfy's adoption advantages stem from its design philosophy: * **2-minute learning curve**: Most users understand the basics immediately * **No technical knowledge required**: Anyone can create and modify processes * **Mobile-first design**: Works seamlessly on any device * **AI assistance**: Generate process templates in seconds * **Legendary support**: Real humans help with adoption challenges * **No complex setup**: Start getting value from day one - **[Troubleshooting](https://tallyfy.com/products/pro/miscellaneous/troubleshooting/)**: Systematic troubleshooting steps including cache clearing browser testing and authentication loop fixes can resolve most Tallyfy loading errors display problems and login issues before requiring support assistance. ## Troubleshooting common Tallyfy issues When Tallyfy experiences problems like pages not loading properly, errors appearing, or features not responding correctly, these systematic troubleshooting steps can resolve most issues before requiring support assistance: 1. **Clear your browser's cache completely**: Outdated website data frequently causes display and functionality problems. Choose your browser for detailed clearing instructions: * [Chrome Cache Clearing Guide](/products/pro/miscellaneous/troubleshooting/clear-cache-chrome/) * [Firefox Cache Clearing Guide](/products/pro/miscellaneous/troubleshooting/clear-cache-firefox/) * [Safari Cache Clearing Guide](/products/pro/miscellaneous/troubleshooting/clear-cache-safari/) * [Edge Cache Clearing Guide](/products/pro/miscellaneous/troubleshooting/clear-cache-edge/) 2. **Test with an alternative web browser**: This diagnostic step helps determine if the issue is browser-specific or affects all browsers. 3. **Verify internet connection stability**: Confirm you have a reliable, consistent internet connection without intermittent disconnections. 4. **Disable browser extensions temporarily**: Browser add-ons like ad blockers, privacy tools, or security extensions can interfere with Tallyfy functionality. Disable them individually to identify conflicts. 5. **Update to the latest browser version**: Ensure you're running the most current version of your web browser for optimal compatibility. ### Forcing your browser to load the latest version Browsers sometimes cache outdated versions of the Tallyfy web application, causing functionality issues. A "hard refresh" forces your browser to bypass cached files and download the most current code directly from Tallyfy's servers. To perform a hard refresh, use your browser's built-in refresh options. Most browsers allow you to right-click the reload button and choose "Empty Cache and Hard Reload" or similar options from the menu that appears. If a hard refresh doesn't help, try clearing your full browser cache using the links in step 1 above. ### Fixing authentication loops when logging in If you're experiencing authentication loops where the system keeps asking for credentials repeatedly, can't properly sign in, or get stuck in a redirect cycle, the solution is to force a complete logout to clear all session data. #### Solution for authentication loop issues :::tip[When to use this solution] Use the logout URL immediately when you experience: - Being asked for credentials repeatedly in a loop - Unable to progress past the login screen - Redirected in circles between login pages - Can't switch between organizations - Stuck on the wrong organization after login - SSO authentication loops - Password reset redirecting to account creation - Any situation where you're "stuck" in the authentication process ::: :::note[Why this happens] Authentication loops typically occur when: - Browser sessions become corrupted or conflicted - Multiple authentication attempts create overlapping sessions - Organization switching leaves residual session data - SSO and regular login methods conflict - Browser extensions interfere with authentication cookies ::: #### Nuclear option: Complete browser data wipe script If the standard logout URL and cache clearing don't resolve persistent login or signout issues, you can use this script to wipe all Tallyfy-related data from your browser. This removes every trace of cookies, localStorage, sessionStorage, IndexedDB, cache storage, and service workers. :::caution[Important limitations] This script cannot wipe data across all Tallyfy origins (e.g., `go.tallyfy.com`, `account.tallyfy.com`) in a single execution because browsers enforce origin-based security. You'll need to run it on each Tallyfy domain you use. Additionally, HttpOnly cookies (server-only) cannot be removed by JavaScript - you'll need to use Chrome's site data settings for those. ::: **How to use this script:** **The script:** ```js (async () => { const log = (...a) => console.log("[tallyfy-all-origins]", ...a); // ---- Cookie helpers const cookieNames = document.cookie .split(";") .map(c => c.trim()) .filter(Boolean) .map(c => c.split("=")[0]); // Build domain candidates: current host chain plus .tallyfy.com (site-wide) const host = location.hostname; // e.g., go.tallyfy.com const parts = host.split("."); const domains = new Set([host, "." + host, ".tallyfy.com"]); for (let i = 1; i < parts.length - 1; i++) { const d = parts.slice(i).join("."); domains.add(d); domains.add("." + d); } // Build path candidates from deep to root const segs = location.pathname.split("/").filter(Boolean); const paths = new Set(["/"]); let acc = ""; for (const s of segs) { acc += "/" + s; paths.add(acc); } const pathList = Array.from(paths).reverse(); const expire = (name, domain, path) => { const pieces = [ `${encodeURIComponent(name)}=`, "Expires=Thu, 01 Jan 1970 00:00:00 GMT", "Max-Age=0", `Path=${path}` ]; if (domain) pieces.push(`Domain=${domain}`); document.cookie = pieces.join("; "); }; try { log(`Attempting cookie deletions for ${cookieNames.length} visible (non-HttpOnly) cookie(s).`); for (const name of cookieNames) { // host-only attempt for (const p of pathList) expire(name, null, p); // domain/path permutations (incl. .tallyfy.com if applicable) for (const d of domains) for (const p of pathList) expire(name, d, p); } log("Cookie deletion attempts complete (covers host-only & domain-scoped variants where JS-visible)."); } catch (e) { console.warn("[tallyfy-all-origins] cookie error:", e); } // ---- Web Storage try { localStorage.clear(); sessionStorage.clear(); log("Cleared localStorage & sessionStorage."); } catch (e) { console.warn("[tallyfy-all-origins] storage error:", e); } // ---- IndexedDB try { if (indexedDB && indexedDB.databases) { const dbs = await indexedDB.databases(); if (Array.isArray(dbs)) { for (const db of dbs) { if (!db?.name) continue; await new Promise(res => { const req = indexedDB.deleteDatabase(db.name); req.onsuccess = req.onerror = req.onblocked = () => res(); }); } } log("Deleted IndexedDB databases for this origin."); } else { log("indexedDB.databases() unsupported here; cannot enumerate DBs."); } } catch (e) { console.warn("[tallyfy-all-origins] indexedDB error:", e); } // ---- Cache Storage (PWA caches) try { if (self.caches?.keys) { const keys = await caches.keys(); await Promise.all(keys.map(k => caches.delete(k))); log("Cleared Cache Storage for this origin."); } } catch (e) { console.warn("[tallyfy-all-origins] cache error:", e); } // ---- Service workers try { const regs = (await navigator.serviceWorker?.getRegistrations?.()) || []; await Promise.all(regs.map(r => r.unregister())); log(`Unregistered ${regs.length} service worker(s) for this origin.`); } catch (e) { console.warn("[tallyfy-all-origins] service worker error:", e); } log("Done on this origin. Repeat on any other Tallyfy origins you use (e.g., go.tallyfy.com, account.tallyfy.com)."); })(); ``` **What this script clears:** - **JavaScript-accessible cookies** for the current origin and `.tallyfy.com` domain - **localStorage and sessionStorage** data - **IndexedDB databases** (if your browser supports enumeration) - **Cache Storage** (Progressive Web App caches) - **Service workers** registered for the current origin **Why you must run per origin:** Browser security (same-origin policy) prevents JavaScript running on one domain from accessing another domain's storage. Each Tallyfy subdomain maintains separate storage that can only be cleared when you're actually visiting that subdomain. **HttpOnly cookies limitation:** HttpOnly cookies are invisible to JavaScript for security reasons. To remove these, use Chrome's built-in site data manager after running the script: 1. Chrome Settings → Privacy and Security → See all site data and permissions 2. Search "tallyfy" 3. Click "Remove" for tallyfy.com This removes all site data including HttpOnly cookies across all Tallyfy subdomains. :::tip[When to use the nuclear option] Use this thorough script when: - The standard logout URL doesn't resolve authentication loops - Clearing cache through browser settings hasn't worked - You're experiencing persistent session conflicts across multiple Tallyfy origins - You need to completely reset your Tallyfy browser state for troubleshooting - You're switching between multiple organizations with conflicting sessions ::: ### Why am I seeing rate limit errors in Tallyfy? Tallyfy implements rate limiting to prevent system abuse and ensure platform stability. When you exceed these limits within specific timeframes, you may encounter temporary restriction errors: | Action | Limit (Approximate) | |------------------------|---------------------------------| | Update Email/Password | 3 times / day | | Update Account Details | 7 times / day | | Send/Resend Invites | 10 times / day | | API Calls | ~140 / 10 secs (can vary) | | API GET Requests | ~12 / 5 secs (can vary) | When you encounter rate limit restrictions, wait the specified time period before attempting the action again. If your legitimate use case requires higher limits (such as API integrations), contact our support team to discuss increased allowances. ### Password reset prompts to create a new account Sometimes members (especially Light members) experience an issue where attempting to reset their password directs them to create a new account instead. This typically happens when the system doesn't properly recognize their existing account status. #### Solution for password reset redirection issues Follow these specific steps to properly reset your password when experiencing this issue: :::note[Why this happens] This issue can occur when browser sessions aren't properly cleared or when there's confusion between member account states. The logout step ensures a clean session before initiating the password reset process. ::: ### Redirected to create an organization after login Sometimes after successfully logging in or resetting your password, you're incorrectly redirected to the organization creation page (`go.tallyfy.com/organizations/create`) instead of your existing organization. This happens when the browser session gets confused about your organization membership. #### Solution for organization creation redirect Follow these steps in exact order to resolve this issue: :::tip[Prevention tip] This issue often affects users who switch between multiple Tallyfy organizations or use shared computers. Always log out completely when switching accounts to prevent session confusion. ::: ### Mobile login issues If you created an account on desktop but can't log in on mobile (or vice versa), follow these steps: **Common causes**: - Browser cookies/cache preventing proper authentication - Using different browsers with conflicting sessions - Auto-fill entering incorrect credentials **Solution**: 1. **Clear mobile browser data** - Go to your mobile browser settings and clear cache/cookies for tallyfy.com 2. **Use the same browser** - Try using the same browser brand on both devices (e.g., Chrome on both) 3. **Check credentials carefully** - Mobile keyboards often auto-capitalize or add spaces 4. **Try incognito/private mode** - This bypasses any stored session issues 5. **Reset password if needed** - Use the password reset flow to ensure you have the correct credentials :::tip[Mobile access works the same] Tallyfy is fully responsive - the same login credentials work on all devices. There's no separate mobile app or different login system. If you can log in on desktop, those exact credentials work on mobile. ::: ### Microsoft login shows "Need admin approval" When signing in with Microsoft, you might see a "Need admin approval" message followed by "Tallyfy API - unverified". This occurs when your organization's Azure Active Directory settings require administrator consent before employees can use third-party applications. **What's happening**: Your company's IT policies restrict which apps can access Microsoft accounts. Tallyfy needs explicit approval from an administrator before any user can sign in with their work Microsoft account. **Immediate workaround for users**: - Click **Return to the application without granting consent** - On the Tallyfy sign-up page, use **email and password** instead of Microsoft sign-in - You can still access all Tallyfy features with a standard email/password account **Permanent solution (requires IT administrator)**: Your IT administrator needs to approve Tallyfy in Azure Active Directory: Once approved, all employees can use Microsoft sign-in immediately. The consent only needs to happen once per organization. If you see error code `AADSTS900144` after returning without consent, this confirms the admin approval requirement. **Additional resources**: - [Microsoft's guide on "Need admin approval" popups](https://learn.microsoft.com/en-us/answers/questions/1497998/need-admin-approval-popup) - [Azure AD consent and permissions documentation](https://docs.microsoft.com/en-us/azure/active-directory/manage-apps/configure-admin-consent-workflow) ### Images loading slowly When Tallyfy images load slowly or fail to appear, these targeted solutions can improve performance: * **Chrome QUIC Protocol Adjustment**: Navigate to `chrome://flags` in the address bar, search for `QUIC`, set it to `Disabled`, and restart Chrome to resolve connection issues. * **Browser Extension Isolation**: Systematically disable extensions one at a time to identify which add-on might be interfering with image loading performance. * **Security Software Configuration**: Temporarily disable firewall or antivirus software to test if these programs are blocking image requests, then configure appropriate exceptions for Tallyfy if needed. ### Browser-specific troubleshooting guides The following section contains guides for resolving issues in specific web browsers: - **[Terms & legals](https://tallyfy.com/products/pro/miscellaneous/terms-legals/)**: Tallyfy maintains SOC 2 Type 2 attestation GDPR compliance HSTS security BIMI email standards custom data processing agreements comprehensive encryption multi-layer API protection AWS GovCloud hosting options and various enterprise-grade security measures to meet regulatory obligations and enterprise requirements. ## Compliance and legal standards Tallyfy maintains [compliance](/products/pro/compliance/), legal, [security](/products/pro/compliance/), and privacy standards designed to meet enterprise requirements and regulatory obligations: * **SOC 2 Type 2 Attestation**: Independently verified security controls and operational effectiveness for data protection. * **HSTS Compliance**: HTTP Strict Transport Security prevents man-in-the-middle attacks. The `tallyfy.com` domain is pre-loaded as secure in major browsers. * **BIMI Compliance**: Brand Indicators for Message Identification email standard enhances brand recognition and prevents phishing attacks. * **Custom Data Processing Agreements**: Available for EU, UK, or specific US states (like CCPA) to meet regional privacy requirements. * **GDPR Compliance**: Achieved through Data Privacy Framework (DPF) attestation for full European data protection. * **Enterprise Contract Flexibility**: Custom contracts available for specialized enterprise requirements and compliance needs. * **Complimentary Single Sign-On**: SSO functionality provided free to all customers because security shouldn't require additional costs. * **Complete Data Encryption**: All data is encrypted both in transit and at rest using industry-standard encryption protocols. * **Logical Data Separation**: Multi-tenant cloud hosting with logical data separation hosted in `us-west-2` on Amazon Web Services. * **AWS GovCloud Hosting**: Available for customers requiring enhanced security standards. Requires enterprise contract - [schedule a consultation](https://tallyfy.com/booking/) for details. * **Multi-Layer API Security**: Every [API](/products/pro/integrations/open-api/) request processes through Cloudflare Workers and Web Application Firewall (WAF) protection. * **Sanctions Compliance**: Access blocked from countries under US trade sanctions to ensure regulatory compliance. * **Anonymous Network Blocking**: Requests from Tor browsers are automatically blocked for enhanced security. * **Edge Rate Limiting**: Advanced rate limiting at network edge handles traffic spikes and prevents abuse. * **Enterprise Insurance Options**: Custom insurance coverage available for enterprises with specific liability requirements. ### Achieving compliance with Tallyfy Tallyfy's [compliance automation software](https://tallyfy.com/solutions/compliance-automation-software/) enables organizations to meet regulatory requirements efficiently through standardized processes, automated compliance tracking, and audit trails that demonstrate adherence to industry standards. ### Support - **[Contact support](https://tallyfy.com/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/)**: Tallyfy provides comprehensive support through in-app help bubbles email assistance and unlimited 25-minute screen-sharing calls plus professional services for complex implementations including dedicated account management process mapping consultation and custom template development. ## Contacting Tallyfy support When you need assistance with Tallyfy, our dedicated support team offers multiple contact methods and help options to resolve your questions quickly and effectively. ### Support options Tallyfy offers multiple support channels to help users at every level: * **In-App Help Bubble**: Click the **Get Help** bubble (typically green, located in bottom right corner). Search help articles or send direct messages with screenshot attachments to our support team * **Email Support**: Send detailed questions directly to `support@tallyfy.com` for written assistance * **Live Screen-Sharing Calls**: Schedule complimentary 25-minute screen-sharing sessions with Tallyfy experts through our [booking page](https://tallyfy.com/booking/) :::tip[Live support calls] We believe in providing excellent support. Customers get **unlimited 25-minute support calls** via screen share. Use the booking link to get help with building templates, setting up integrations, troubleshooting, or any other questions. ::: ### Professional services For complex projects requiring extensive consultation or specialized expertise, Tallyfy provides Professional Services engagements. Our support team identifies when your needs align with these services, which include: * **Dedicated Account Manager**: Receive a specialized expert assigned exclusively to your account for ongoing strategic support * **Process Mapping Consultation**: Professional assistance mapping complex business processes before implementing them in Tallyfy * **Workflow Optimization Analysis**: Expert evaluation and improvement recommendations for workflow efficiency and effectiveness * **Custom Template Development**: Professional creation of sophisticated templates tailored to your specific business requirements * **Pilot Program Implementation & ROI Analysis**: Comprehensive assistance setting up pilot programs, measuring success metrics, and calculating quantifiable return on investment * **Advanced Integration Design**: Specialized help designing, configuring, and testing complex connections to external systems and platforms * **Change Management & Team Training**: Strategic guidance for rolling out Tallyfy organization-wide and ensuring successful team adoption - **[In-app user guide](https://tallyfy.com/products/pro/miscellaneous/support/how-to-access-the-tallyfy-user-guide/)**: Tallyfy provides an integrated user guide accessible through the Help button in the left sidebar or the Help and FAQs option in your profile menu for instant workflow support without interrupting your work. ## Finding the in-app user guide Tallyfy includes a built-in user guide that provides instant access to answers and step-by-step guides while you work. This integrated support ensures you can resolve questions without leaving your current workflow. Two primary access methods are available when logged into Tallyfy: - **[Provide context to support](https://tallyfy.com/products/pro/miscellaneous/support/how-to-provide-necessary-info-to-tallyfy-support/)**: When contacting Tallyfy support you should provide the complete URL from your browser's address bar and your Organization ID found in Settings to help them quickly locate and resolve your specific issue. ## Information to provide to Tallyfy support To help the Tallyfy support team understand and resolve your issue quickly, they might ask you for specific information. Two critical pieces of information they commonly need are: 1. **The Full URL (Web Address)**: If your question is about a specific [task](/products/pro/tracking-and-tasks/tasks/), running [process](/products/pro/tracking-and-tasks/processes/), [template](/products/pro/documenting/templates/), or even a specific [guest task link](/products/pro/documenting/guests/how-to-find-a-guest-task-link-in-tallyfy/), please copy the *entire* web address from your browser's address bar (starting with `https://go.tallyfy.com/...`) and paste it into your support ticket or email. 2. **Your Organization ID**: This unique ID helps support quickly locate your specific account. You can find it by navigating to **Settings** > **Organization** in Tallyfy. Copy the ID displayed there and provide it to support. See also: [Find your Tallyfy IDs](/products/pro/miscellaneous/how-to-find-your-tallyfy-ids/). Providing these critical details helps the support team locate the exact item you're referring to much faster and more efficiently. - **[Share screenshots](https://tallyfy.com/products/pro/miscellaneous/support/how-to-share-screenshots-and-screencasts-with-tallyfy-support/)**: Screenshots and screencasts help Tallyfy support teams quickly understand and resolve issues by providing visual documentation of problems through screen captures using keyboard shortcuts on Mac and Windows or screen recordings using free tools like Loom Screencastify and Recordit. ## Sharing screenshots and screencasts with support Sending a picture (screenshot) or a short video recording (screencast) of the issue you're experiencing can help the Tallyfy support team understand the problem faster and more accurately. Here's how to capture these effectively: ### Taking screenshots * **On a Mac**: Press `Shift + Command (⌘) + 3` keys together to capture your entire screen. (Other combinations like `Shift + Command + 4` let you select a specific area). * **On Windows**: Press the `PrtScn` (Print Screen) key (you might need to press `Fn` or `Ctrl` simultaneously on some keyboards). This usually copies the screen image to your clipboard. You can then paste it into an image editor (like Paint) or directly into your support message. Some Windows versions also have a Snipping Tool for easier, more precise captures. ### Recording screencasts If the issue involves multiple steps or something moving on the screen, a short video is often more effective. Here are some excellent free tools you can use: * **Loom**: [https://www.useloom.com/](https://www.useloom.com/) (User-friendly, popular Chrome extension) * **Screencastify**: [https://www.screencastify.com](https://www.screencastify.com/) (Also a widely-used Chrome extension) * **Recordit**: [http://recordit.co/](http://recordit.co/) (Simple, straightforward tool for quick screen recordings) These tools allow you to record your screen (and optionally your voice narration) and easily share a video link with the support team for clearer communication. - **[Not receiving emails?](https://tallyfy.com/products/pro/miscellaneous/support/not-receiving-emails-from-tallyfy-how-to-troubleshoot/)**: Tallyfy email delivery issues can stem from incorrect addresses or notification settings or spam filtering or corporate security systems and can be resolved through IT allowlisting of tallyfy.com or checking Microsoft-specific diagnostic tools like SNDS and Message Trace or verifying email authentication status or using alternative direct link sharing methods for guest tasks. ## Not receiving emails from Tallyfy When you or your [guests](/products/pro/documenting/guests/) stop receiving emails from Tallyfy, several factors could be blocking delivery. This troubleshooting guide helps resolve email delivery issues and ensures consistent communication. ### Allowlisting configuration guides for IT teams If your IT team needs specific guidance on allowlisting Tallyfy emails, these official resources provide step-by-step instructions: * [Allowlist in G Suite / Google Workspace](https://support.google.com/a/answer/60751) * [Allowlist in Office 365 / Microsoft 365](https://learn.microsoft.com/en-us/microsoft-365/security/office-365-security/create-safe-sender-lists-in-office-365) * For other email systems, refer to their specific documentation on adding email addresses or domains to a safe sender list (allowlist). ## Troubleshooting Microsoft email systems Microsoft email systems (Outlook.com, Hotmail, Office 365, Exchange Online) use sophisticated spam filtering that sometimes blocks legitimate emails. Here's how to diagnose and resolve these issues. ### Understanding Microsoft's two email systems Microsoft operates two separate email infrastructures - understanding which one applies to your situation is critical: **Consumer services** (Outlook.com, Hotmail, Live, MSN): - Personal email accounts ending in @outlook.com, @hotmail.com, @live.com, @msn.com - Sender reputation monitored through SNDS (Smart Network Data Services) - Users can mark emails as spam or not spam - Governed by Microsoft's consumer email policies **Business services** (Office 365, Exchange Online, Microsoft 365): - Corporate and educational email domains like @yourcompany.com or @university.edu - Uses Exchange Online Protection (EOP) spam filtering - Managed by organization IT administrators - Separate filtering policies and controls The troubleshooting steps differ significantly depending on which system is blocking your emails. ### For consumer services - Checking sender reputation If emails aren't reaching Outlook.com or Hotmail addresses, check Tallyfy's sending reputation: **Microsoft SNDS portal**: 1. Visit [SNDS](https://sendersupport.olc.protection.outlook.com/snds/)[1] 2. Sign in with a Microsoft Account 3. Request access to Tallyfy's sending IP addresses 4. Check daily traffic light indicators (green = good, yellow = warning, red = blocked) 5. Monitor spam complaint rates and trap hits **What the indicators mean**: - Green status: Good sender reputation, emails should deliver normally - Yellow status: Some issues detected, delivery may be degraded - Red status: Significant problems, emails likely blocked - Trap hits above zero: Emails sent to inactive addresses (list hygiene issue) - Complaint rate above 0.1%: Users marking emails as spam Note that SNDS only covers consumer services - it won't help diagnose Office 365 delivery issues. ### For business services - Working with IT administrators Office 365 and Exchange Online filtering happens at the organization level. Your IT administrator has tools to diagnose why Tallyfy emails aren't arriving: **Message Trace** (primary diagnostic tool): Your IT admin can run Message Trace in the Exchange Admin Center to see: - Whether Tallyfy emails reached Microsoft servers - Spam Confidence Level (SCL) scores assigned to emails - Specific filtering rules that blocked delivery - Whether emails went to inbox, junk folder, or quarantine **Typical findings**: - SCL 5-6: Email marked as spam, delivered to Junk folder - SCL 7-9: High confidence spam, quarantined or rejected - Authentication failures: SPF, DKIM, or DMARC checks failed - Policy blocks: Organization rules preventing delivery **What IT can do to allow Tallyfy emails**: 1. Add tallyfy.com to the Tenant Allow/Block List 2. Create Mail Flow Rule to bypass spam filtering for Tallyfy 3. Add to organization-wide Safe Senders list 4. Adjust anti-spam policy thresholds 5. Release emails from quarantine and mark as not spam ### Checking authentication status Microsoft requires proper email authentication for bulk senders. Here's how to verify Tallyfy's authentication is working: **Using mail-tester.com**: 1. Visit [mail-tester.com](https://www.mail-tester.com/)[2] 2. Note the test email address provided 3. Send a Tallyfy email to that address (create a test task assigned to yourself) 4. Check your score (should be 10/10) 5. Review any authentication issues flagged **What to look for**: - SPF record: Should show "pass" for Tallyfy's domain - DKIM signature: Should be present and valid - DMARC policy: Should align with SPF and DKIM - Spam score: Should be low (under 3.0) If authentication issues appear, contact Tallyfy support - these are infrastructure-level configurations we manage. ### If your IP is blocklisted Sometimes Microsoft blocklists sending IP addresses due to spam complaints or suspicious activity. Here's how to check and resolve: **Check blocklist status**: 1. Visit [Microsoft sender support](https://sender.office.com/)[3] 2. Enter the sending IP address (Tallyfy support can provide this) 3. Review blocklist status 4. Submit mitigation request if blocked **Delist process**: - Provide detailed explanation of issue resolution - Wait 24-48 hours for Microsoft review - Monitor SNDS for reputation improvement - Consider requesting dedicated sending IP from Tallyfy for isolated reputation Note: Delisting only works after addressing the root cause (typically spam complaints or sending to invalid addresses). ### Understanding email headers If you receive a Tallyfy email in your Junk folder, the email headers contain diagnostic information: **Key headers to review**: - `X-Forefront-Antispam-Report`: Shows SCL score, SPF/DKIM/DMARC results - `Authentication-Results`: Detailed authentication check results - `X-MS-Exchange-Organization-SCL`: Spam confidence level (0-9 scale) - `Received-SPF`: SPF check pass/fail status Your IT administrator can extract and interpret these headers through Message Trace or by viewing the email source. ### Preventative measures Beyond reactive troubleshooting, these practices help maintain good email deliverability: **For users**: - Never mark Tallyfy emails as spam - use notification preferences instead - Add no-reply@tallyfy.com to your personal Safe Senders list - If using Focused Inbox, move Tallyfy to Focused tab - Report persistent issues to your IT team promptly **For IT administrators**: - Allowlist tallyfy.com domain rather than individual addresses - Monitor quarantine for false positives - Review spam policies quarterly - Document Tallyfy as approved business system - Consider tenant-wide Mail Flow Rules for critical workflow systems **For Tallyfy administrators in your organization**: - Use reliable, permanent email addresses for [members](/products/pro/documenting/members/) and [guests](/products/pro/documenting/guests/) - Avoid disposable or temporary email services - Maintain clean lists - remove bounced addresses - Monitor notification settings to prevent overload - Test new processes with small user groups first ### When to contact Tallyfy support Reach out to [Tallyfy support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/) if you experience: - Emails blocked despite IT allowlisting Tallyfy domain - Consistent authentication failures in mail-tester.com - High spam scores (over 5.0) in testing tools - Widespread delivery issues across multiple organizations - Blocklist issues that persist after delisting We can investigate infrastructure-level issues, coordinate with Mailgun (our email provider), and escalate to Microsoft if needed. ### Troubleshooting - **[Clear cache in Chrome](https://tallyfy.com/products/pro/miscellaneous/troubleshooting/clear-cache-chrome/)**: Clearing Chrome's browser cache removes corrupted temporary files and forces the browser to download fresh content from Tallyfy's servers which resolves display problems loading errors and outdated content issues. ## Clearing Chrome's cache to fix Tallyfy issues Clearing Chrome's cache resolves display problems, loading errors, and outdated content issues in Tallyfy by removing stored temporary files that may be corrupted or outdated. This process forces Chrome to download fresh content from Tallyfy's servers. ### After clearing Chrome's cache After successfully clearing the cache, completely close Chrome and reopen it before accessing Tallyfy again. This ensures all cached data is properly removed and Chrome starts with a clean slate. :::note[Common issues resolved by clearing cache] Clearing your browser cache can often fix problems like: - Pages not loading or displaying correctly - Login difficulties - Forms not submitting - Seeing old content instead of updates ::: ### If clearing cache doesn't resolve the issue If clearing Chrome's cache doesn't resolve your Tallyfy problems, please [contact Tallyfy support](https://tallyfy.com/contact-us/) for additional Tallyfy troubleshooting assistance and specialized help. - **[Clear cache in Edge](https://tallyfy.com/products/pro/miscellaneous/troubleshooting/clear-cache-edge/)**: Clearing Microsoft Edge's browser cache removes temporary files and corrupted data to resolve Tallyfy display problems loading errors and performance issues by forcing the browser to download fresh content from servers. ## Clearing Edge's cache to fix Tallyfy issues Clearing Microsoft Edge's cache eliminates display problems, loading errors, and outdated content issues in Tallyfy by removing temporary files that may be corrupted or outdated. This process ensures Edge downloads fresh content from Tallyfy's servers. ### After clearing Edge's cache After successfully clearing the cache, completely close Microsoft Edge and reopen it before accessing Tallyfy again. This ensures all cached data is properly removed and Edge starts fresh. ### Clearing cache for only Tallyfy in Edge If you prefer to clear cache data specifically for Tallyfy without affecting other websites: ### If clearing cache doesn't resolve the issue If clearing Edge's cache doesn't resolve your Tallyfy problems, please [contact Tallyfy support](https://tallyfy.com/contact-us/) for additional Tallyfy troubleshooting assistance and specialized help. - **[Clear cache in Firefox](https://tallyfy.com/products/pro/miscellaneous/troubleshooting/clear-cache-firefox/)**: Firefox browser cache clearing resolves Tallyfy performance issues by removing corrupted temporary files and ensuring fresh content downloads from servers through the Privacy & Security settings menu. ## Clearing Firefox's cache to fix Tallyfy issues Clearing Firefox's cache eliminates performance problems, loading errors, and outdated content issues in Tallyfy by removing temporary files that may be corrupted or outdated. This process ensures Firefox downloads fresh content from Tallyfy's servers. ### After clearing Firefox's cache After successfully clearing the cache, completely close Firefox and reopen it before accessing Tallyfy again. This ensures all cached data is properly removed and Firefox starts with a clean slate. ### If clearing cache doesn't resolve the issue If clearing Firefox's cache doesn't resolve your Tallyfy problems, please [contact Tallyfy support](https://tallyfy.com/contact-us/) for additional Tallyfy troubleshooting assistance and specialized help. - **[Clear cache in Safari](https://tallyfy.com/products/pro/miscellaneous/troubleshooting/clear-cache-safari/)**: Clearing Safari's browser cache on Mac and iOS devices removes corrupted temporary files that can cause loading problems and display issues in Tallyfy by enabling the Develop menu or using Privacy settings on Mac and accessing Safari settings on iOS devices. ## Clearing Safari's cache to fix Tallyfy issues Clearing Safari's cache eliminates loading problems, display issues, and outdated content in Tallyfy by removing temporary files that may be corrupted or outdated. The Tallyfy troubleshooting process varies between Mac computers and iOS devices. ### Clearing Safari cache on Mac #### Complete cache and data clearing ### Clearing Safari cache on iOS devices ### After clearing Safari's cache After successfully clearing the cache, completely close Safari and reopen it before accessing Tallyfy again. This ensures all cached data is properly removed and Safari starts with a clean slate. ### If clearing cache doesn't resolve the issue If clearing Safari's cache doesn't resolve your Tallyfy problems, please [contact Tallyfy support](https://tallyfy.com/contact-us/) for additional troubleshooting assistance. ### Additional troubleshooting help If clearing the Safari cache doesn't resolve your issue, explore additional solutions in the [Tallyfy troubleshooting guide](/products/pro/miscellaneous/troubleshooting/) for other potential fixes. ### Terms legals - **[Country restrictions](https://tallyfy.com/products/pro/miscellaneous/terms-legals/is-your-country-blocked-from-using-tallyfy/)**: Tallyfy restricts access from eleven countries including Cuba Iran Syria North Korea Libya Somalia Iraq Russia Yemen Palestine and Tor exit nodes due to US trade sanctions and regulatory compliance requirements. ## Countries that cannot access Tallyfy As a US corporation, Tallyfy must comply with United States regulations and trade sanctions. This compliance requirement means access from specific countries is currently restricted. We sincerely apologize for any inconvenience this causes. ### Blocked locations The following locations currently cannot access Tallyfy due to regulatory compliance: * **CU** - Cuba * **IR** - Iran * **SY** - Syria * **KP** - North Korea * **LY** - Libya * **SO** - Somalia * **IQ** - Iraq * **RU** - Russia * **YE** - Yemen * **PS** - Palestine * **T1** - Tor exit nodes (anonymous network access points) ### Requesting an exception If you believe your situation qualifies for an exception or need assistance regarding access restrictions, please [contact our team](https://tallyfy.com/contact-us/) to discuss potential solutions within regulatory guidelines. - **[Tallyfy's privacy policy](https://tallyfy.com/products/pro/miscellaneous/terms-legals/where-can-i-find-tallyfys-privacy-policy/)**: Tallyfy's privacy policy and security documentation can be accessed through dedicated web pages that outline data collection practices protection measures and compliance standards. ## Tallyfy's privacy policy Tallyfy's privacy policy details how we collect, use, and protect your personal information. You can review our complete privacy policy at [https://tallyfy.com/legal/privacy-policy/](https://tallyfy.com/legal/privacy-policy/). ### Security documentation Detailed information about our IT infrastructure, security protocols, and compliance best practices is available at [https://tallyfy.com/legal/compliance-security/](https://tallyfy.com/legal/compliance-security/). This documentation covers our security frameworks, data protection measures, and operational safeguards. ### Documenting - **[Documents](https://tallyfy.com/products/pro/documenting/documents/)**: Document templates in Tallyfy let you create policies and reference materials with locked standard content and editable fields that maintain brand consistency while allowing users to customize specific details in minutes instead of hours. ## Understanding document templates Document templates in Tallyfy help you create policies, reference materials, and guides where people don't need to follow a strict sequence. Think of them as smart forms[^1] - they keep your documents looking perfect while saving hours of formatting time. Here's how they work. Document templates lock down your standard text and formatting, but include editable fields where users add their specific details. Perfect consistency meets real-world flexibility. Unlike [procedure templates](/products/pro/documenting/templates/) designed for sequential step-by-step workflows (such as employee onboarding processes), document templates excel for information sharing that doesn't need strict task sequencing or workflow dependencies. Document templates also support [knowledge-only mode](/products/pro/tutorials/knowledge-only-mode/) - publish them as searchable reference materials that teams can access without launching formal processes. Perfect for policies, guidelines, and SOPs that people need to read but not track. ### Advantages of document templates - **Brand Consistency**: Every document looks exactly the same - same fonts, same layout, same professional appearance across all teams - **Operational Efficiency**: What used to take hours now takes minutes. Users just fill in the blanks instead of starting from scratch - **Quality Assurance**: Nobody can accidentally mess up your standard content. The important stuff stays locked while users customize what they need - **Centralized Updates**: Change the template once, and all future documents get the update. No more hunting down outdated versions - **Universal Accessibility**: Works on any device - phone, tablet, computer. No downloads, no special software These features significantly reduce document creation time - giving you real time back in your day. ### Document template structure Document templates have two parts: 1. **Fixed Content Sections**: The stuff that never changes - your standard text, formatting, headers, footers. Users can't touch these parts, which keeps everything consistent 2. **Dynamic Editable Fields**: The blanks users fill in. Name fields, dates, specific details - whatever makes each document unique Simple. Your documents stay on-brand while users add what they need. ### Working with document templates #### Types of document templates you can create You can build templates for pretty much any document your organization uses: - **Corporate Policies** (social media guidelines, remote work rules, code of conduct) - **Procedural Guidance** (how to talk to clients, meeting protocols, escalation paths) - **Reference Materials** (vendor contacts, security codes, resource lists) - **Legal Documents** (contracts, agreements, compliance forms, terms of service) - **Business Proposals** (sales decks, project proposals, partnership agreements) - **Intake Forms** (client info sheets, vendor onboarding, assessment questionnaires) - **Standard Operating Instructions** (equipment guides, safety procedures, tech manuals) Companies often use these templates for the majority of their documents - turning hours of work into minutes. #### Deploying document templates When you launch a document template, here's what happens: 1. **Instance Creation**: Tallyfy creates a fresh copy of your template as an active process. You can track who's working on it and when 2. **Controlled Editing**: Users can only change the fields you've marked as editable. Everything else stays locked 3. **Consistent Output**: Every completed document looks exactly like your template intended Launch, fill in, done. Each document meets your standards without the hassle. #### Digital documents vs. traditional files Remember wrestling with Word documents? Tallyfy online documents fix those headaches: - **Automated Formatting**: No more fiddling with fonts and margins. Your templates handle all the formatting automatically - **Clear Edit Boundaries**: You can instantly see what's editable (highlighted fields) and what's locked. No accidents - **Version Control**: One document, one location. No more "Final_v3_REALLY_final.docx" chaos - **Content Reusability**: Use snippets[^2] to drop in standard text blocks. Write once, use everywhere - **Multilingual Support**: Built-in translation for global teams (yes, really) - **Cross-Platform Compatibility**: Works the same on phones, tablets, computers. No weird formatting issues Bottom line? You spend far less time managing documents and more time getting actual work done. ### Tallyfy Documents vs. Microsoft Word Here's how Tallyfy documents compare to programs like Microsoft Word: | Feature | Tallyfy Documents | Microsoft Word | |---------|-------------------|----------------| | **Main Use** | Reading and working together online | Mostly for printing, but can be used online | | **Formatting** | Consistent style set for the whole company; text is cleaned up | Manual formatting for each document | | **Navigation (TOC)** | Table of contents made automatically from headings | Table of contents needs to be created and updated manually | | **Version Control** | One main version; changes are tracked | Often results in many different file versions | | **Working Together** | Real-time access based on roles; connects to workflows | Sharing files; fewer options for working together live | | **Images** | Optimized for web viewing; sizing options | More formatting options for print and screen | :::tip[Moving from Word to Tallyfy] When copying text from Word into Tallyfy, focus on bringing over the words first. Then, use Tallyfy headings (H1, H2, H3) to structure the content. Tallyfy removes Word's formatting when you paste, ensuring your documents look clean and consistent with your company's style. ::: [^1]: Dynamic forms with locked standard content and editable fields for user input [^2]: Reusable text blocks in Tallyfy that can be inserted across multiple documents - **[Groups](https://tallyfy.com/products/pro/documenting/groups/)**: Tallyfy groups enable efficient task assignment by organizing collections of people into reusable teams that automatically update membership when staff changes occur and allow mixed collaboration between internal members and external guests. ### Understanding groups in Tallyfy Groups let you assign tasks to entire teams at once - think of them as saved lists of people you work with regularly. Simple. Instead of clicking "assign" and adding people one by one (we've all wasted time on that), you just pick the group. Your workflow setup that used to take 10 minutes? Now it's done in seconds. #### Key benefits of using groups - **Faster task assignment**: One click assigns the whole team - **Consistent workflows**: Same groups work across all your processes[^2] - **Automatic updates**: Someone leaves? They're out of all groups automatically - **Smooth transitions**: New team members get added once and they're ready to go Here's where it gets really useful - if you're running the same workflows every week or month, groups save you from repetitive setup work. #### Group composition example Let's say you create an "Accounting Team" group: - Jane Doe (member) - Jill Ramirez (member) - tim.smith@gmail.com (guest[^1]) Notice that last one? You can mix your internal team with external partners in the same group. Your auditor, consultant, or client can work right alongside your staff. #### Automatic membership management This is my favorite part. When someone leaves your company, Tallyfy removes them from every group automatically. No hunting through workflows to clean up assignments. - New hires join their groups on day one - instant access to all their workflows - External guests work seamlessly with your team (yes, still free and unlimited) - Everything stays current without you lifting a finger The result? Less time managing people lists, more time getting work done. [^1]: External users who can participate in workflows at no cost using guest_code authentication [^2]: Groups are global entities that can be reused in any blueprint or run within your organization - **[Guests](https://tallyfy.com/products/pro/documenting/guests/)**: External guests can participate in specific workflow tasks through secure email links without needing full Tallyfy accounts while internal team members maintain oversight and control over the collaboration process. ## Guest functionality for external collaboration Guests let you include clients, suppliers, and partners in your workflows without giving them full Tallyfy accounts. They complete specific tasks through secure email links - and it's completely free with unlimited access. Simple. This makes guests ideal for [client onboarding](https://tallyfy.com/solutions/client-onboarding-software/) where external stakeholders need to participate. Think of it this way: You're running a 20-step approval process, but steps 5 and 12 need client input. Instead of managing those separately, guests complete their parts right within your workflow. Everything stays tracked in one place. :::tip[Member vs. Guest: Employee Badge vs. Visitor Pass] Here's an easy way to think about the difference: - **[Member](/products/pro/documenting/members/):** Like an **employee** with a company **ID badge**. They log into Tallyfy, have a specific role (Admin, Standard, or Light), and can access different parts of Tallyfy based on their role, just like an employee uses their badge to get into different office areas - **Guest:** Like a **visitor** given a temporary **visitor pass** for one specific meeting or task. They don't get a full login or badge. Their pass is the unique *forever link[^1]* sent in their email. This link lets them access *only* the specific task they need to work on, like a visitor pass only works for one specific room. They can't access other tasks or processes This lets you work with outside people on specific tasks without giving them access to your whole Tallyfy account. ::: ### Assigning workflow tasks to external guests Just assign any step to an email address outside your organization - that person becomes a guest. It's that straightforward. When you're building your template, you've got three assignment options: - **Specific people or teams** in your organization - **Job titles** like "Account Manager" or "Project Lead" (great for role-based workflows) - **External email addresses** for clients and partners who need to complete certain steps Here's what's interesting: Every guest task must also have an internal assignee. Why? You need someone inside your organization keeping tabs on external participation. Makes sense, right? ### Security and access features #### Secure access for guest users * **Unique Access Links**: Each guest gets their own private link to access tasks. We call it a "forever link" because it stays the same unless you change their email or manually reset it. No passwords needed. * **Frictionless Access**: Click the link, complete the task. Done. No account creation, no login screens - just direct access to what they need to do. Your clients will love how easy this is. And you'll love that it's still secure. #### Visibility and delegation capabilities * **Controlled Visibility**: Guests only see their specific tasks - nothing else. Got a 20-step process where the client handles steps 5 and 12? They'll only see those two steps. Your internal workflow stays confidential. (Quick note: If you make a process [public](/products/pro/tracking-and-tasks/processes/make-a-process-public/), guests can see everything in the Tracker view.) * **Flexible Task Delegation**: Sometimes your client contact is out sick. No problem - guests can reassign their tasks to colleagues by adding their email addresses. Perfect balance: Clients get what they need, you keep control of the bigger picture. #### Internal oversight with guest assignments * **Mandatory Internal Assignment**: Remember how every guest task needs an internal assignee too? That's by design. Someone in your organization always has visibility into what's happening with external tasks. * **Automated Communication**: Tallyfy sends reminder emails automatically. You won't need to chase clients for responses - the system handles it. This dual-assignment setup keeps everything on track without extra effort from you. #### Customization and management options * **Email Customization**: Your guests control how often they hear from Tallyfy. They can switch to daily digests if they prefer fewer emails. It's their choice. * **Communication History**: Need to check what emails went to a specific guest? Head to **Settings > Guests** and you'll see everything - every reminder, every notification. Great for audit trails. * **Language Flexibility**: Working with international clients? Guests can change their display language, and if you've set up automatic translation, they'll see task instructions in their preferred language too. Guests get the flexibility they want. You get the tracking you need. ### Guest email preference limitations **Limited control compared to members**: Guests have restricted email preference options. **What guests CAN control**: - Daily digest emails (on/off) - Combine all notifications into one daily summary - Marketing communications (on/off) - Control promotional emails **What guests CANNOT control**: - Individual task notification emails - Always sent when tasks are assigned - Comment notification emails - Always sent when someone comments - Process status update emails - Always sent for major status changes - Deadline reminder emails - Always sent as deadlines approach **Why these limitations exist**: - **Simplified experience** - Reduces complexity for occasional external users - **Ensures task completion** - Critical notifications can't be accidentally disabled - **System design** - Granular preferences require full member dashboard access **For more email control**: If a guest needs detailed email preferences, consider: - Converting them to a Light member[^2] role (view-only access) - Using member-level permissions instead of guest access - Managing notifications at the process level through automation rules ### Guest task completion experience **Making task completion clear for guests**: Tallyfy designs the guest interface to be intuitive and action-oriented. **How guests complete tasks**: - Email notifications include clear instructions and a prominent link - The green **Complete** button is prominently displayed on every task - Automatic reminders are sent based on your configured cadence - Task descriptions can include step-by-step instructions for clarity **Tips for clearer guest tasks**: - Add explicit instructions in the task description like "Click the green Complete button when done" - Use numbered steps in task descriptions for complex actions - Include screenshots or examples when helpful - Set appropriate deadlines to create urgency :::tip[Alternative: Expiring tasks for optional guest work] For low-priority guest tasks that might not get completed, use **expiring tasks** that auto-complete on the deadline: 1. In the template, set the task type to **Expiring** 2. Set an appropriate deadline (e.g., 3 days) 3. The task automatically completes if the guest doesn't respond 4. Perfect for optional feedback requests or "nice to have" input This prevents processes from getting stuck on unresponsive external parties. [Learn more about task types](/products/pro/tracking-and-tasks/tasks/what-types-of-tasks-can-i-create-with-tallyfy/). ::: To learn more about guests: [^1]: Unique guest_code URL parameter that persists unless manually reset or email changed [^2]: View-only role with full dashboard access but no task completion permissions - **[Templates](https://tallyfy.com/products/pro/documenting/templates/)**: Templates in Tallyfy are reusable blueprints that transform business processes into automated workflows with three stages - document your procedures and run consistent processes and improve based on real data - solving common problems like inconsistent quality and knowledge loss while supporting both multi-step procedure templates and smart document templates. ## Working with templates Templates are reusable blueprints that turn your business processes into self-driving workflows. Create once, use forever - that's the power of Tallyfy templates. Whether you're building a [standard operating procedure](https://tallyfy.com/standard-operating-procedure-sop/) or documenting complex workflows, templates provide the foundation. Templates capture every step, decision point, and handoff in your workflows. When you launch a template, Tallyfy creates a live process that runs itself - assigning tasks, sending reminders, and tracking progress automatically. Update a template once and every future process gets the improvement. ### The three-stage workflow approach 1. **Document** - Capture your process knowledge in smart templates 2. **Run** - Launch consistent, trackable processes every time 3. **Improve** - Optimize based on real data and feedback You document what should happen, run it consistently to see what actually happens, and improve based on real-world insights. ### Common workflow problems Every time someone asks "How do we do this again?", you're losing money. Templates fix that permanently. Without templates, companies face these expensive problems: - **Quality varies wildly** - same process, different results depending on who does it - **Time bleeds away** - people reinvent workflows daily instead of doing actual work - **Knowledge walks out the door** - when Sarah leaves, her process expertise leaves too - **Onboarding takes weeks** - new hires fumble through undocumented processes Tallyfy templates solve this in one shot. They become your single source of truth - dramatically cutting training time and virtually eliminating process errors. Better yet? Fix the template once, and everyone benefits instantly. :::note[Template vs. Blueprint] In the Tallyfy app, we call these **Templates**. If you use the Tallyfy API (for coding integrations), they are called **Blueprints**. It's the same thing, just different names. ::: Templates work for small, repetitive tasks too. Client check-ins, expense approvals, content reviews - Tallyfy handles these "papercut" processes that eat up hours. Create a 5-step template in minutes, save 5 hours weekly. ### Key benefits - **Same process, same quality** - Every client gets your A-game service, not whoever's version - **Create once, use 1000x** - That onboarding template? Launch it for every new hire in seconds - **Zero interpretation needed** - Clear steps mean no confusion, no "I thought you meant..." - **Scale without chaos** - Handle 10x more work with the same team The result? Significantly faster process completion and far fewer questions about "how to do things." ### Document → Run → Improve cycle **Stage 1: Document (Build the template)** - Capture your best practices in a reusable template - Define who does what, when, and how - Add smart rules for different scenarios - Build once, use thousands of times **Stage 2: Run (Launch processes)** - Start new processes from your template in seconds - Track progress in real-time - Ensure nothing falls through cracks - Maintain consistency across all instances **Stage 3: Improve (Optimize continuously)** - Analyze completion times and bottlenecks - Gather feedback from process participants - Update the template based on insights - Every future process benefits instantly ### Template types Tallyfy gives you two template types that cover every business need: 1. **Procedure Templates**: Your multi-step workflows that run from start to finish. - **Sequential vs parallel execution**: All tasks appear simultaneously by default (parallel) - multiple people work on different tasks at once, significantly cutting completion time. Need sequential order? Use automation rules to show tasks only after previous steps complete - Add if-this-then-that rules ("If budget > $5000, add CFO approval") - Auto-assign to people or job titles[^1] - new hires get tasks immediately - Collect data with smart forms that validate entries - Connect to your other tools - no manual data entry - *Real examples*: Onboard employees in 5 days not 3 weeks, approve purchases in hours not days, publish content with zero missed steps Use procedure templates when you need trackable multi-step workflows. Tasks run in parallel by default for speed, but you can enforce sequential order where dependencies exist. :::note[Tallyfy approach vs. flowcharts] Instead of complex flowcharts, Tallyfy uses a simple checklist style for steps, combined with "if-this-then-that" rules. This makes processes easier for everyone to understand, build, and follow, while still handling decisions and different paths. ::: 2. **Document Templates**: Smart forms and policies that update themselves. - Lock down sections that can't change (legal disclaimers stay perfect) - Add fill-in fields for custom details - no more "[INSERT NAME HERE]" mistakes - Professional formatting every time - no wrestling with Word - Use snippets[^2] - update once, flows to all documents instantly - *Real examples*: Employee handbooks ready in minutes, contracts that auto-populate client data, policies that track who's read them Use document templates for anything people need to reference or fill out - but don't need step-by-step tracking. ### Knowledge-only mode Not every procedure needs tracking. [Knowledge-only mode](/products/pro/tutorials/knowledge-only-mode/) lets you publish templates as searchable reference materials without formal process execution. Perfect for: - How-to guides and SOPs teams reference while working - Training materials and best practices - Company policies and guidelines - Quick reference checklists Your team searches for "how to process a refund" and finds the current procedure instantly - no outdated wikis, no scattered documents. They read it and apply it without launching a formal tracked process. ### Template lifecycle #### 1. Template Creation: Get templates up and running in under 10 minutes: - **From scratch**: Drag-drop interface for custom workflows - **AI-powered**: Describe your process, Tallyfy writes the template in 60 seconds - **Upload existing docs**: Turn that Word SOP into a live workflow instantly - **Import from anywhere**: Moving from another tool? Bring your workflows - **Clone and tweak**: Love your invoice process? Copy it for purchase orders #### 2. Template Management: Find any template in 3 seconds: - **Smart folders**: Organize by team, client type, or frequency - **Tag everything**: Filter by "customer-facing" or "compliance" instantly - **Lock it down**: Control who sees and edits each template - **Clear ownership**: Template Owners get alerts about needed updates - **Archive outdated templates**: Remove templates from active view without deleting #### 3. Template Launch: From template to running process in one click: - **Quick setup**: Fill a short form, Tallyfy handles the rest - **Smart assignments**: Tallyfy assigns based on workload and skills - **Live tracking**: See exactly where every process stands - clients love this :::note[Template vs. Process: Building Analogy] A **template** is like the **master blueprint** for a house. It defines the standard design. When you use that blueprint to build a specific house, that's like **launching a process**. Each house built (each running process) is unique, even if based on the same blueprint. Each needs its own unique name or address (like "123 Main St Build" or "Job #567") so you can track that specific project separately. ::: ### Measurable results - **Dramatically fewer errors**: Everyone follows the same proven steps - **Faster onboarding**: New hires productive in days, not weeks - **Instant improvements**: Fix a template Monday, everyone benefits Tuesday - **Knowledge stays forever**: When Bob retires, his expertise lives on in templates - **Audit-ready always**: Every step tracked, every decision documented ### Can I move a template inside another template? Yes, Tallyfy offers two powerful ways to move a template inside another template: 1. **Content embedding**: Use [snippets](/products/pro/documenting/templates/snippets/) to embed template links and reusable content within task descriptions for reference and guidance. 2. **Runtime injection**: Use the ["launch another process"](/products/pro/launching/launch-process-when-task-is-completed/) feature with **"inject tasks into existing process"** to automatically add entire template workflows into running processes based on conditions. Both approaches let you build modular, reusable workflow components that can be combined dynamically. ## Template organization Templates not placed in folders appear in the **Uncategorized** view in your Templates section. This helps keep your templates organized as it grows - we recommend creating folders to group related templates for easier navigation. **Important:** The Uncategorized folder is a system folder that cannot be deleted. It serves as the default location for templates that haven't been organized into custom folders. To organize templates: 1. Navigate to **Templates** and select **Uncategorized** 2. Click the folder icon next to any template 3. Choose **Move to folder** and select or create a destination folder **Note:** The Templates view shows recent template activity, making it easy to see what has changed recently. While you cannot delete the Uncategorized folder, you can keep it empty by organizing all templates into custom folders. ## Next steps Learn how to [create a template](/products/pro/documenting/templates/create-template/) in 10 minutes. Most users have their first process running within an hour. [^1]: Role-based assignments that auto-update when someone changes positions or joins the team [^2]: Reusable content blocks that auto-sync across all templates when updated once - **[Members](https://tallyfy.com/products/pro/documenting/members/)**: Members are people in your organization with Tallyfy access who work on business processes regularly and come in three roles: Administrator with complete control and Standard for regular employees with full workflow capabilities and Light for those who only need to complete tasks without creating templates. ## What are members in Tallyfy? Members are people in your organization with Tallyfy access - your employees, contractors, or anyone who needs to work on business processes and workflows regularly. Managing members effectively is essential for processes like [employee onboarding](https://tallyfy.com/solutions/employee-onboarding-software/) where new hires need appropriate access levels. Here's the key difference: Members have full account access and count toward your account limits[^1]. Guests? They're external users with limited access. ### The three member roles You'll assign each member one of three roles. Let's break them down: - **Administrator**: Complete control over everything in Tallyfy - settings, members, system configuration. Be careful who gets this role since it gives unlimited access. - **Standard**: The most common role for regular employees who need full workflow capabilities. Admins can customize their specific permissions based on job needs. - **Light**: Can complete tasks and give feedback on processes, but can't create or edit templates. Perfect for people who follow processes rather than design them. :::tip[Understanding Member Roles Through Key Card Security Analogy] Visualize Tallyfy roles as sophisticated key card access levels for a secure office building: - **Administrator:** Has the **master key card** with universal access. Can enter all areas, modify security settings (equivalent to changing locks), and determine access rights for other personnel. Reserve this role exclusively for highly trusted individuals. - **Standard:** Holds a **departmental employee key card**. Accesses designated work areas and specific rooms required for job functions (process execution, potential template editing if authorized), while restricted from high-security areas (organizational settings). - **Light:** Carries a **task-focused access key card**. Enters assigned work areas to complete specific job responsibilities (task completion, feedback provision) but can't access design areas (template creation or editing). ::: ### Member role categories Simple: - **Full roles**: Administrator and Standard roles both count as "Full" members with complete platform capabilities - **Light roles**: Designed for team members who just need to complete tasks without template creation access [^1]: Account limits are based on your subscription tier and determine the max number of active members ### Documents - **[Add fields to documents](https://tallyfy.com/products/pro/documenting/documents/how-can-i-add-editable-fields-to-my-tallyfy-documents/)**: Document templates in Tallyfy function as smart forms with editable fields for variable content like names dates and descriptions while keeping standard text locked to ensure consistent professional documents that can reuse the same field data across multiple locations. ## How to add editable fields to document templates [Document templates](/products/pro/documenting/documents/) in Tallyfy work like smart forms - you fill in the blanks while the rest stays locked. Simple. This keeps every document consistent and saves you hours of formatting headaches. ### Requirements - You'll need edit permissions for document templates. - Know which parts of your document should be editable [fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) (think: what changes each time?). ### Types of editable fields Tallyfy gives you three types of editable [fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) to work with: 1. **Short text** - Names, titles, reference numbers. The quick stuff. 2. **Long text** - Think paragraphs, detailed explanations, the works. 3. **Date** - Deadlines, start dates, you name it. ### Adding new fields Ready to add a field? Here's how: ### Reusing existing fields Need the same field in multiple spots? No problem - you don't have to create it twice: ### How fields work in launched documents Here's the magic: when someone [launches](/products/pro/launching/) a document template with [fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/), everything just works: - They fill in the editable fields first - that's it. - Got the same field in multiple places? Enter it once, it appears everywhere. Seriously. - Everything else? Locked down tight. - Your documents come out perfect every time. Professional look, consistent structure - the whole package. ### Tips for using document fields After helping hundreds of teams set up their templates, here's what actually matters: - **Name fields clearly.** I can't stress this enough - "Customer Name" prevents confusion, "Name" causes headaches. Clear naming significantly reduces user errors. - **Match field size to content.** Short fields for company names, long fields for those detailed project descriptions. - **Group related stuff together.** Your users will thank you. - **Don't go overboard.** Too many fields? People freeze up. Keep it focused. - **Test it yourself first.** [Launch](/products/pro/launching/) your own [document template](/products/pro/documenting/documents/) before anyone else does. Trust me on this one. - **[Digital signatures](https://tallyfy.com/products/pro/documenting/documents/how-can-i-automate-document-signing-with-tallyfy/)**: Tallyfy connects to e-signature services through middleware tools to automatically send documents for signing when workflow steps complete saving teams 15-20 minutes per document with no manual intervention required. ## How to automate document signing using helper tools (middleware) Connect Tallyfy to e-signature services like DocuSign or HelloSign through [middleware](/products/pro/integrations/middleware/) tools - when someone completes a workflow step, documents automatically go out for signing. No manual work. Most teams save 15-20 minutes per document[^1]. Simple. ### What you need - A Tallyfy account with [webhook](/products/pro/integrations/webhooks/) access - A [middleware](/products/pro/integrations/middleware/) account (Zapier, Power Automate, or Make.com work great) - An e-signature service account (DocuSign or HelloSign) - A document [template](/products/pro/documenting/templates/) ready in your signature service :::note[Setting up middleware] If you haven't used middleware before, check our [middleware integration guide](/products/pro/integrations/middleware/) for setup instructions and platform comparisons. ::: ### How it works (overview) ### Document signing automation flow This shows the complete automation pathway from workflow completion to signed document tracking. [Diagram removed for brevity] **What to notice:** - **Steps 2-3**: The webhook fires instantly[^2] when someone completes a Tallyfy step - no delays or manual triggers needed - **Step 4**: Middleware handles all the field mapping automatically - you set it up once and it works every time - **Steps 7-8**: The optional return path creates a complete loop - Tallyfy knows when documents get signed without you checking ### Step 1: Create a listening point (webhook) in your middleware Here's how this works in most middleware platforms: ### Step 2: Set up your Tallyfy Process ### Step 3: Connect your e-signature service in the middleware Time to link everything together. You'll do this inside your middleware tool. #### For HelloSign #### For DocuSign ### Step 4: Testing and turning on the connection ### Tracking when the document is signed Want the full automation experience? You can set up a return path so Tallyfy knows when documents get signed: Here's what happens when it all comes together: 1. Someone completes a Tallyfy step - document goes out for signing. No waiting around. 2. Recipient signs the document. 3. Tallyfy updates instantly to show the signing task is done. That's it. Your signing workflow runs itself. [^1]: Based on eliminating manual downloading, uploading, and tracking steps in traditional signing workflows [^2]: Typically processes within 1-2 seconds of task completion, depending on network latency - **[Create a table of contents](https://tallyfy.com/products/pro/documenting/documents/how-to-create-a-table-of-contents-in-tallyfy/)**: Tallyfy automatically creates navigable table of contents from document headings that update in real-time without manual maintenance unlike traditional word processors that require constant refreshing and formatting fixes. ## How automatic table of contents work in Tallyfy Tallyfy automatically generates a table of contents from your headings - just add headings and watch the navigation build itself. No manual linking, no updating page numbers. Your [documents](/products/pro/documenting/documents/) and [procedure templates[^1]](/products/pro/documenting/templates/) become instantly navigable. ### What you need - A document or procedure template open for editing - Text you want to organize with headings ### How Tallyfy's table of contents is different from Word's Remember fighting with Word's table of contents? Page numbers that won't update, manual refreshing, formatting that breaks? Tallyfy works differently: - **Instant creation**: Add a heading - it appears in the navigation immediately - **Live updates**: Change a heading and the table of contents updates in real-time - **Screen-optimized[^2]**: Built for clicking and navigating, not printing - **Zero maintenance**: Never manually update navigation again ### Creating a table of contents in Documents Here's where it gets good - watch your table of contents build itself: That's it. Your headings instantly appear in the table of contents panel as clickable links. ### Tips for using headings well Want a table of contents that actually helps readers? Follow these rules: - **H1** is for main sections only - think chapter titles - **H2** goes inside H1 sections - your subchapters - **H3** goes inside H2 sections (if you really need that level) - Don't skip levels - no jumping from H1 to H3 - Keep headings short. Really short. ### Table of contents in Procedure templates Procedure templates work a bit differently. You still get automatic navigation - you just access it through preview mode: ### Why automatic table of contents matter Think about the last time you scrolled endlessly through a long document, hunting for that one section you needed. Frustrating, right? With Tallyfy's automatic table of contents: - Readers grasp your document structure in seconds - One click takes them anywhere - no scrolling marathons - You're forced to organize content logically (trust me, this is good) - 50-page documents become as easy to navigate as 5-page ones - Everyone knows exactly what they're getting before they dive in [^1]: Reusable process workflows that become active 'runs' when launched with assigned tasks [^2]: Navigation anchors use HTML IDs instead of page numbers for instant browser-based jumping - **[Generate documents](https://tallyfy.com/products/pro/documenting/documents/how-to-generate-documents-from-form-fields/)**: Tallyfy form data can automatically generate contracts reports or signature requests through middleware connections to document services like WebMerge or DocuSign taking about 15 minutes to configure and eliminating manual data copying between systems. ## How to automatically generate documents from Tallyfy form data You can automatically create contracts, reports, or signature requests directly from Tallyfy form responses - it takes about 15 minutes to set up. Here's how. ### What you'll need - A Tallyfy [template](/products/pro/documenting/templates/) with [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) that collect your data - A [middleware](/products/pro/integrations/middleware/) account (see our middleware guide for platform comparisons) - A document creation service (like WebMerge/Formstack Documents, DocuSign, HelloSign - pick your favorite) ### The basic idea When someone completes a form in Tallyfy, that data automatically flows to your document service to create PDFs, Word files, or trigger signature requests. No manual copying[^2]. The magic happens through [middleware](/products/pro/integrations/middleware/) that connects everything together. ### Step 1: Set up your Tallyfy template ### Step 2: Configure your middleware connection ### Step 3: Connect your document service ### Step 4: Deliver documents and track signatures ### Demo video The following video demonstrates this process: [^1]: Task IDs use a 32-character hash format unique to each task instance in the system [^2]: Data flows via webhook events triggered on task completion, processed by middleware - **[Launch document templates](https://tallyfy.com/products/pro/documenting/documents/how-to-launch-and-use-document-templates/)**: Creating document instances from templates in Tallyfy involves clicking Launch Document on template cards filling out a kick-off form with required information and then viewing or editing the generated document that merges template content with entered data. ## How to create document instances from templates To launch a document template in Tallyfy, just click **Launch Document** on any template card in your library - this creates a new document where you fill in the editable fields through a simple form. It's that straightforward. Once you've created a [Document Template](/products/pro/documenting/documents/), you can launch as many instances as you need. Each launched document combines your template's fixed content with the specific data you enter. ### How to launch Done. Tallyfy creates your launched document instance, automatically populating it with the information you just entered. ### Viewing and editing the launched document Here's what happens after you launch: [^1]: Pre-launch data collection form that populates all editable template fields in a single interface ### Groups - **[Create and assign groups](https://tallyfy.com/products/pro/documenting/groups/how-to-manage-groups-and-assign-tasks-in-tallyfy/)**: This documentation explains how to create groups in Tallyfy for organizing team members and guests then assign these groups to tasks in process templates with options to control the maximum number of assignees and use automation rules for dynamic assignments. ## Managing groups and assigning tasks ### What you'll need - Administrator or Standard [member](/products/pro/documenting/members/) permissions - Access to the **Settings** section ### Creating new groups :::tip[Using Groups for Recurring Guests] Here's a time-saver: Create groups with guest emails you use often (like your client's team). You won't have to type those same email addresses again and again. ::: ### Assigning groups to tasks in templates When you're working with a process [template](/products/pro/documenting/templates/), it's simple: ### Setting options for group assignments You've got a few ways to control how group assignments work: - **Enforce maximum number of assignees[^2]** - this limits how many people from the group can work on one task - Once enabled, you'll set your maximum number - Need assignments that change based on what's happening in your process? That's where [assignment actions](/products/pro/documenting/templates/automations/actions/asignment-actions/) come in :::note[How group assignments work] When you assign a [task](/products/pro/tracking-and-tasks/tasks/) to a group, the person launching the process decides who actually gets it - they can pick specific people from that group or assign everyone (depends on how you've set things up). Here's the thing: In templates, you can only assign the whole group or specific people - there's no middle ground. Once the process is running though? Any group member can jump in, edit the assignment, and take ownership. ::: [^1]: Unlimited free external users who access processes via guest_code without creating accounts [^2]: Prevents task bottlenecks by distributing work across multiple group members simultaneously ### Guests - **[Assigning guests](https://tallyfy.com/products/pro/documenting/guests/guest-user-guide/)**: Guest users in Tallyfy allow external collaborators like clients vendors and contractors to complete assigned tasks through secure email links without creating accounts or incurring costs while maintaining limited access to only their specific assigned work. ## How to assign, manage, and convert guests Need to include external people in your workflows? Guest users let you do exactly that - they can complete tasks without creating accounts or costing you extra. Here's everything you need to know. ### Understanding guest users #### What are guest users? Think of guests as your external collaborators - clients, vendors, contractors - anyone outside your organization who needs to complete specific tasks. They're: - External participants who don't need a Tallyfy account - Unlimited and free to include in your processes - Limited to completing only tasks assigned specifically to them - Identified by their email address #### Guests vs. members comparison | Feature | Guest Users | Regular Members | |---------|------------|----------------| | Cost | Free, unlimited | Paid, based on subscription | | Account needed | No | Yes | | Can create templates | No | Yes (Standard/Admin) | | Can launch processes | No | Yes (with permissions) | | Task visibility | Only assigned tasks | All tasks (based on role) | | Process visibility | Limited to their tasks | Full process view | | Authentication | Email-based link | Login credentials | | Can be assigned tasks | Yes | Yes | | Can create tasks | No | Yes (with permissions) | ### Inviting and managing guests #### How to assign tasks to guests You've got two ways to bring guests into your workflows: 1. **In a template** (for repeatable processes): - Select a step in your template - Go to the **Assignment** tab - Select "Guest" as the assignment type - Enter the guest's email address 2. **In an active process** (for on-the-fly changes): - Navigate to the task you want to assign - Click **Reassign** - Select "Assign to guest" - Enter the guest's email address - Click **Save** That's it. No complex setup required. #### Guest notification options Here's what happens when you assign a task to a guest - they'll receive an email with a secure link straight to their task[^1]. No passwords to remember. No accounts to create. You can: - Customize the email notification message - Set up reminder notifications for uncompleted tasks - Track exactly when they access their tasks - Keep everything moving smoothly #### Tracking guest progress Want to know how your guests are doing? The Tracker view shows you everything at a glance - which tasks are complete, which are pending, and who's working on what. You can also check task history to see when guests accessed their work and use comments to keep communication flowing (yes, guests can see @mentions directed at them). ### Common guest scenarios #### Collecting information from customers Need customer data? Guest tasks make it simple. Use them to gather information through forms, collect document uploads, get approvals or signatures, and request feedback. Your customers get a clean, professional interface - you get the data you need. Everyone wins. #### Involving external experts or partners Sometimes you need outside expertise. Maybe it's a legal review, technical consultation, or vendor approval. Guest access lets these external experts drop in, contribute their piece, and move on. They provide specialized input, review deliverables, approve changes, or add their expertise to specific steps - all without the overhead of full user accounts. #### Onboarding new clients Here's where guest tasks really shine. Create an onboarding process that guides new clients through every step they need to complete. They'll submit required documentation, fill out necessary forms, and receive information exactly when they need it. You'll capture everything systematically. No back-and-forth emails, no missing paperwork. ### Document collection workflows **Perfect for loan applications, mortgage processing, or compliance checks**. Set up a guest checklist where external users can: - See required documents with explanations for each - Upload files directly to their assigned tasks - Check off completed items as they go - Get clear instructions at every step Example setup for mortgage applications: 1. Create tasks for each document type (W2s, bank statements, ID verification) 2. Add detailed guidance text explaining what's needed 3. Include file upload fields in each task 4. Assign all tasks to the guest's email 5. They work through the checklist at their own pace ### Troubleshooting guest access issues #### Guest can't access their task Getting "I can't access my task" messages from guests? Don't panic. Here's your troubleshooting checklist: 1. Double-check the email address (typos happen more than you'd think) 2. Here's a common gotcha - guest emails can't be from your company domain. If your organization uses `mydomain.com`, guest emails ending in `@mydomain.com` won't work. They'll need to use a personal email instead. 3. Check if the task link has expired 4. Resend the invitation from the task view 5. Make sure the process is still active (completed processes lock everyone out) 6. Verify the task hasn't been reassigned to someone else Still stuck? The issue is usually #2 - the domain restriction catches a lot of people. #### Guest completed a task by mistake Accidents happen. If a guest clicks "Complete" too soon, you can fix it in seconds: 1. Navigate to the completed task 2. Click the **Reopen** option in the task menu 3. The task returns to "In Progress" status 4. The guest can access it again with their original link No need to create new tasks or reassign anything. #### Changing guest email address Wrong email? Easy fix. Just go to the task, click **Reassign**, enter the correct guest email address, and click **Save**. Tallyfy sends a fresh invitation to the new address automatically. The old link stops working immediately - good for security. ### Security and privacy considerations #### Guest data access limitations Tallyfy keeps guest access locked down tight. Here's exactly what guests can and can't see: **Guests CAN see:** - Their specific assigned tasks - Attachments or fields within those tasks - Comments where they're @mentioned **Guests CANNOT see:** - Other tasks in the process - Your templates or organization settings - Member information or other processes - Historical data outside their tasks Simple as that. They see their work, nothing more. #### Public processes and guest visibility :::warning[Important security consideration] Here's something that trips people up: When you make a process **[Public to the world](/products/pro/tracking-and-tasks/processes/make-a-process-public/)**, the rules change completely. - **Private process** (default): Guests see only their assigned tasks. Period. - **Public process**: Guests can see **all tasks** in the Tracker view - including tasks assigned to other guests or members Why does this matter? Let's say you have multiple vendors working on different parts of a public process. They'll be able to see each other's tasks in the Tracker view. Not ideal if you're managing competitive bids or confidential work. Keep processes private when: - Different external guests shouldn't see each other's work - Task titles or descriptions contain sensitive information - You need strict task-level access control ::: #### Best practices for guest security Want to keep things secure? Follow these guidelines: - Share only what's necessary in guest tasks (less is more) - Use form fields to collect information instead of exposing sensitive details - Keep confidential data out of task descriptions and attachments - Set expiration times on guest task links when dealing with time-sensitive information - Review and remove guest access when projects wrap up - don't let old links linger ### Converting between guests and members #### Converting a guest to a member Sometimes a guest needs more access - maybe a contractor becomes an employee, or a client needs deeper involvement. You can convert them in two ways. ##### Before you start - Administrator permissions are required - The person should already be a guest in your Tallyfy account - You need an available member seat in your subscription ##### Method 1: Convert from the Guests list ##### Method 2: Invite as a member 1. Navigate to **Settings > Members** 2. Click **Invite member** 3. Enter the guest's email address 4. Select the appropriate role (Standard, Light[^2], or Administrator) 5. Click **Send** ##### What happens after conversion - The new member receives an email and sets a password on first login - They initially appear as a Standard member (you can change this later) - They occupy a paid member seat in your subscription - You can adjust their role anytime in **Settings > Organization > Members** ##### Why convert someone? - Full Tallyfy access based on their role (Standard, Light, or Administrator) - Ability to create and manage [processes](/products/pro/tracking-and-tasks/processes/) - Their own secure login and password - Visibility into entire workflows - not just their [tasks](/products/pro/tracking-and-tasks/tasks/) #### Converting a member to a guest Going the other direction? Maybe someone's involvement is scaling back. Here's how: 1. Go to **Settings > Members** 2. Find the member you want to convert 3. Click the three dots menu and select **Convert to guest** 4. Confirm the change Done. They can still complete guest tasks but won't have member privileges anymore. ### Advanced guest features #### Guest form submission without task assignment Need to collect information from a large group? You don't have to assign individual tasks. Instead, create a process with a form, generate a shareable link, and send it out. Anyone with the link can submit the form - perfect for surveys, registrations, or feedback collection. Tallyfy captures every submission automatically. #### Custom branding for guest interfaces First impressions matter. When guests interact with your processes, they should see your brand, not ours. Customize the experience with your logo, welcome messages, and branded email notifications. Even the task descriptions can reflect your organization's voice and style. The bottom line? Guest users give you flexibility without complexity. You can include anyone in your workflows - clients, vendors, partners - without user management headaches or extra costs. They get a smooth experience, you maintain control, and everyone stays focused on getting work done. [^1]: Links contain a unique guest_code token that authenticates without requiring account credentials [^2]: Light users have view-only permissions and cannot complete tasks, unlike guest users who can complete assigned tasks - **[The guest view](https://tallyfy.com/products/pro/documenting/guests/how-can-guests-monitor-their-processes-on-tallyfy/)**: The guest dashboard serves as a personal command center where external users can view all assigned tasks across different processes access them through email links or a simple login page and complete work by filling forms uploading files commenting and tracking progress with clear visual indicators and status updates. ## The guest dashboard Your [guest](/products/pro/documenting/guests/) dashboard shows all [tasks](/products/pro/tracking-and-tasks/tasks/) assigned to you across different Tallyfy [processes](/products/pro/tracking-and-tasks/processes/) - think of it as your personal command center. You'll find everything you need to complete your work without juggling multiple emails or systems. Simple. ### How guests get to their dashboard You can access your dashboard two ways: 1. Click the **special [task link](/products/pro/documenting/guests/how-to-find-a-guest-task-link-in-tallyfy/)** in your email notification - it takes you straight there 2. Visit [https://go.tallyfy.com](https://go.tallyfy.com/) and enter your email address That's it. No passwords, no complicated logins[^1]. ### What's on the dashboard Here's what you'll see when you log in: - **Process list**: Every process where you have work to do - **Task cards**: Your specific assignments displayed clearly - **Status markers**: Visual indicators showing whether tasks are pending, in progress, or complete - **Comments section**: Where you can ask questions or provide updates (yes, it's that straightforward) - **Attachments**: All files you need for each task - **Due dates**: Clear deadlines so you know what's urgent ### Using the dashboard #### Seeing process details Want to dive deeper into a specific process? Here's how: 1. Find the [process](/products/pro/tracking-and-tasks/processes/) you need on your dashboard 2. Click its name - this opens the detailed view 3. You'll see all [tasks](/products/pro/tracking-and-tasks/tasks/) assigned specifically to you within that process No hunting around. Just your work, clearly laid out. #### Working on tasks Ready to tackle a task? The process couldn't be simpler: 1. Click the [task](/products/pro/tracking-and-tasks/tasks/) you want to complete 2. Review the instructions - they tell you exactly what's needed 3. Fill in any [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) or upload required files 4. Questions? Drop them in the comments 5. Hit **Complete** when you're finished Done. #### Tracking progress You'll always know where things stand: - Completed tasks show a checkmark - Your current task is highlighted - can't miss it - Future tasks display when they'll unlock[^2] - A progress bar reveals how far along the entire process has come It's like having a GPS for your work. ### Guest capabilities As a [guest](/products/pro/documenting/guests/) user, you can: - Complete any [tasks](/products/pro/tracking-and-tasks/tasks/) assigned to you - Access all documents and files attached to your tasks - Leave comments and ask questions directly on tasks - Monitor the overall progress of [processes](/products/pro/tracking-and-tasks/processes/) you're participating in - Receive email updates about your assignments (and control how often) :::note[Managing Notifications] Guests can adjust their email notification frequency - daily, weekly, or somewhere in between - through a settings option right in their guest view. You're in control. ::: [^1]: Uses magic link authentication via guest_code parameter for secure passwordless access [^2]: Tasks unlock based on prerequisites completion and configured deadlines (hour/day/week/month units) - **[Assign tasks to guests](https://tallyfy.com/products/pro/documenting/guests/how-can-i-assign-tasks-to-guest-users-in-tallyfy/)**: Tallyfy allows you to assign tasks to guest users by simply entering their email address when assigning any task which sends them a secure link to complete their work without requiring an account creation. ## How to assign tasks to guest users Assigning tasks to guest users in Tallyfy is straightforward - just enter their email address when assigning any task, and they'll receive a secure link[^1] to complete their work without needing an account. Here's exactly how to do it. ### What you need - Administrator or Standard [member](/products/pro/documenting/members/) permissions (Light users can't do this) - The [guest](/products/pro/documenting/guests/) user's email address - A process [template](/products/pro/documenting/templates/) or running [process](/products/pro/tracking-and-tasks/processes/) with the [task](/products/pro/tracking-and-tasks/tasks/) you want to assign :::note[Guest email domain restriction] Guest email addresses cannot be from the same domain as your organization. For example, if your company uses `mydomain.com` email addresses, you cannot assign guest tasks to emails ending in `@mydomain.com`. This restriction ensures proper separation between internal members and external guests. ::: ### Method 1: Assign when building the template The most efficient approach? Set up guest assignments right in your template. That way, every time someone launches the process, the right external people get their tasks automatically. When someone [launches](/products/pro/launching/) this template later, Tallyfy automatically assigns this [task](/products/pro/tracking-and-tasks/tasks/) to your specified guest. No extra steps needed. :::note[Assigning many tasks quickly] If you need to assign many [tasks](/products/pro/tracking-and-tasks/tasks/) to guests in a template, try using the [Power Assign](/products/pro/documenting/templates/how-can-power-tools-enhance-my-tallyfy-experience/) tool to speed things up. ::: ### Method 2: Assign after starting the process Sometimes you realize mid-process that you need external help. No problem - you can assign tasks to guests even after a [process](/products/pro/tracking-and-tasks/processes/) is already running. Done. The guest receives an email with a secure link to view and complete their task - they won't need to create an account or remember any passwords. ### Method 3: Assign using a comment Here's a neat trick: you can assign a [guest](/products/pro/documenting/guests/) simply by mentioning their email in a [task](/products/pro/tracking-and-tasks/tasks/) comment. Quick and easy. Example comment: ``` +guest.email@example.com Please review this. ``` The moment you type `+guestemail@domain.com` in a comment, Tallyfy assigns that [guest](/products/pro/documenting/guests/) to the [task](/products/pro/tracking-and-tasks/tasks/). This works when editing [templates](/products/pro/documenting/templates/) or in tasks of running [processes](/products/pro/tracking-and-tasks/processes/). It's the fastest way to bring outside people into your workflow - especially handy when you're already discussing the task in comments. ### What happens after you assign a task to a guest? Once you've assigned a task to a [guest](/products/pro/documenting/guests/), here's what they experience: - They receive an email with a secure [link](/products/pro/documenting/guests/how-to-find-a-guest-task-link-in-tallyfy/) directly to their task - They click the link and complete the task - no login required, no passwords to remember - If they have multiple tasks, they'll see them all on their personal [guest dashboard](/products/pro/documenting/guests/how-can-guests-monitor-their-processes-on-tallyfy/) - Once they mark it complete, you'll see "Completed" status in your [process view](/products/pro/tracking-and-tasks/tracker-view/) Simple for them, transparent for you. :::tip[Troubleshooting guest email delivery] **Guest not receiving emails?** Check these common issues: 1. **Email not confirmed** - Did you press Enter/Return after typing the email? This is required to register the email properly 2. **Task not active yet** - Guests only get notified when their task becomes active (not when it's waiting) 3. **Email in spam folder** - Ask guest to check spam/junk and whitelist tallyfy.com 4. **Member co-assignment** - Ensure at least one member is also assigned (guests can't be assigned alone) 5. **Wrong email address** - Verify spelling and that it's not from your organization's domain 6. **Process not launched** - If assigning in template, the process must be launched first 7. **Owner re-assignment bug** - If removing the process owner causes the owner to be re-added automatically, keep the owner assigned but add the guest as a co-assignee. The guest will still receive their task notification. 8. **UI state issues** - If the guest assignment button appears grayed out or unclickable, try: refreshing the page, checking you have proper permissions, ensuring the task is in an editable state, or using a different browser Find the guest link manually: **Settings** > **Organization** > **Guests** to resend. ::: ### Managing tasks assigned to guests Need to keep track of guest assignments? Tallyfy makes it easy: - View all guest tasks in one place: **Settings** > **Organization** > **[Guests](/products/pro/documenting/guests/)**. - Lost a guest link? Find and resend [guest links](/products/pro/documenting/guests/how-to-find-a-guest-task-link-in-tallyfy/) anytime. - Monitor progress through your [process dashboard](/products/pro/tracking-and-tasks/tracker-view/) - see exactly which guest tasks are pending or complete. - Need to reassign? You can change task assignments whenever necessary. ### Understanding member co-assignment with guest tasks **Important behavior**: When you assign a task to a guest, you (or another member) are automatically co-assigned to that task. :::caution[Guest-only assignment not allowed] **You cannot assign a task to ONLY guests.** At least one internal member must always be co-assigned to any guest-facing task. This is a system requirement that cannot be bypassed. If you try to assign a task to only guests (removing all members), the system will automatically keep or add a member to maintain the co-assignment requirement. ::: **Why this requirement exists**: 1. **Comment routing** - Guest questions and comments need a member to receive notifications 2. **Approval authority** - Members maintain oversight and can approve guest work 3. **System notifications** - Ensures someone internal tracks guest task progress 4. **Accountability** - Creates clear ownership for external collaboration 5. **Guest limitations[^2]** - Guests cannot @-reply internal members (member list is private to guests) **Impact on your task list**: - Guest tasks appear in your personal task list until completed - If you delegate 10 guest tasks, you'll have 10 pending tasks yourself - These tasks remain "active" for you even if the guest is working on them **Managing the task burden**: - **Current workaround**: Use filters to separate your actual work from guest oversight tasks - **Future solution**: A "watching" feature is in development that will: - Allow monitoring guest tasks without being assigned - Send notifications without cluttering your task list - Maintain oversight with less administrative burden - Separate "doing" tasks from "monitoring" tasks **Best practice**: Designate specific team members as guest task coordinators to centralize this oversight role rather than distributing it across many employees. [^1]: Uses a unique guest_code hash for authentication without passwords or accounts [^2]: Member list is private to protect organization directory from external visibility - **[Re-open tasks as a guest](https://tallyfy.com/products/pro/documenting/guests/how-can-i-re-open-a-completed-guest-task/)**: Members with Administrator or Standard permissions can re-open completed guest tasks by navigating to the process clicking the completed task and using the Re-Open button which automatically changes the status back to active and notifies the guest via email. ## Re-opening completed guest tasks ### Why guests can't re-open their own tasks [Guests](/products/pro/documenting/guests/) can only complete a [task](/products/pro/tracking-and-tasks/tasks/) once. They can't re-open tasks after completing them. This keeps decisions final and prevents confusion in later process steps. But here's the thing - sometimes guests need to add information after they've hit submit. When that happens, they have two options: - Add comments to the completed task - Ask a [member](/products/pro/documenting/members/) of your team to re-open the task for them ### What you need to re-open a guest task - You must be a member with Administrator or Standard permission - There must be a guest task that's already been completed ### Steps to re-open a Guest task Remember, only members can do this - not guests themselves: ### Sending the task link again After you re-open a [task](/products/pro/tracking-and-tasks/tasks/), you might need to resend the link: ### Where guests see re-opened tasks [Guests](/products/pro/documenting/guests/) find all their assigned [tasks](/products/pro/tracking-and-tasks/tasks/) - including re-opened ones - on their **[Guest Dashboard](/products/pro/documenting/guests/how-can-guests-monitor-their-processes-on-tallyfy/)**. They can leave comments there too, which keeps the conversation going even after task completion. - **[Get a guest's unique link](https://tallyfy.com/products/pro/documenting/guests/how-to-find-a-guest-task-link-in-tallyfy/)**: Guest task links are web addresses that allow external people to access specific tasks without creating a Tallyfy account and can be found either from the task menu in a running process or from the main guest list in Settings. ## Finding and sharing guest task links Need to share a task with someone outside your company? [Guest](/products/pro/documenting/guests/) task links make it simple - they're web addresses that let external people access specific [tasks](/products/pro/tracking-and-tasks/tasks/) without creating a Tallyfy account. No login required. Here's the useful part: these links stay active even after the guest completes their task. Why? Sometimes you need to [reopen](/products/pro/documenting/guests/how-can-i-re-open-a-completed-guest-task/) completed tasks. ### What you need - The [task](/products/pro/tracking-and-tasks/tasks/) must already be assigned to a [guest](/products/pro/documenting/guests/) user - You'll need Administrator or Standard [member](/products/pro/documenting/members/) permissions ### Method 1: From the task itself This is the quickest way when you're already looking at the task: ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-copy-guest-link.png) ### Method 2: From the main guest list in Settings Want to find links for multiple guests? Or can't remember which process contains their task? Use this method: ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-copy-guest-link-from-settings.png) ### Sharing the link :::tip[Programmatic access to guest URLs] **Need guest URLs for your own communication system?** While the UI provides manual access to guest links, you can also retrieve them programmatically: 1. Use the Tallyfy API to query process tasks 2. Extract the guest_url field from task objects 3. Send these URLs through your own email/SMS systems 4. Consider webhooks to capture URLs when tasks are created This enables custom communication workflows while maintaining Tallyfy's task tracking. ::: Got the link? Perfect. Here's what happens next: - Paste it anywhere - email, Slack, text message, carrier pigeon (okay, maybe not that last one) - When the [guest](/products/pro/documenting/guests/) clicks it, they'll land directly on their assigned task. No login screens, no password resets, no hassle. - The link stays active as long as the task exists That's it. Simple. - **[What is a guest](https://tallyfy.com/products/pro/documenting/guests/what-is-a-guest/)**: Tallyfy guests are external collaborators like clients suppliers and contractors who complete specific workflow tasks through secure email links without needing accounts or paid seats while maintaining limited access only to their assigned tasks. ## What is a guest in Tallyfy? [Guests](/products/pro/documenting/guests/) are people outside your company - clients, suppliers, contractors - who need to complete specific [tasks](/products/pro/tracking-and-tasks/tasks/) in your workflows. They don't need Tallyfy accounts or paid seats. Here's the brilliant part: Your guests receive secure email links to their tasks, complete them, and that's it. No logins, no complexity. ### Key characteristics of Tallyfy guests Think of guests as having a VIP pass to just their part of your workflow - nothing more, nothing less. Here's what makes the guest system work so well: - **External Stakeholders**: Your clients, suppliers, contractors, and business partners who need to participate in specific parts of your workflows - **External Access**: Guests can participate without needing internal accounts - **Secure Task Access**: Each guest gets unique [task links](/products/pro/documenting/guests/how-to-find-a-guest-task-link-in-tallyfy/) via email. Click the link, complete the task - it's that straightforward - **Limited Visibility**: Guests only see their assigned tasks. They can't wander around your other [processes](/products/pro/tracking-and-tasks/processes/) or access company data - **Data Protection**: Your organizational information stays completely isolated from guest access. Perfect security boundaries ### Common ways to use Guests You'll find guests perfect for: - Getting approvals from clients - Asking external people to review documents - Collecting information from suppliers for purchasing - Gathering customer feedback - Getting sign-offs from partners or stakeholders ### Member vs Guest comparison Here's how members and guests differ in Tallyfy: #### What Members can do - Log into Tallyfy with an email and password - Create and manage process [templates](/products/pro/documenting/templates/) (depending on their role) - [Start](/products/pro/launching/) and track [processes](/products/pro/tracking-and-tasks/processes/) - View information across the whole organization (based on their role) - [Invite](/products/pro/documenting/members/how-to-invite-and-activate-members-on-tallyfy/) other members and guests - Take up a paid seat in your subscription #### What Guests can do - Access specific [tasks](/products/pro/tracking-and-tasks/tasks/) through unique email links - no login needed - Complete [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) in their assigned tasks - Upload any files their tasks require - Add comments on their tasks (and only their tasks) - View all their assigned tasks on the [guest dashboard](/products/pro/documenting/guests/how-can-guests-monitor-their-processes-on-tallyfy/) - Receive email notifications about task updates ### What Guests cannot do - Re-open [tasks](/products/pro/tracking-and-tasks/tasks/) once they've completed them - Modify task details like due dates or assignments - Access process [templates](/products/pro/documenting/templates/) or view [processes](/products/pro/tracking-and-tasks/processes/) they're not involved in - [Start new processes](/products/pro/launching/) - See tasks assigned to other people - Log into the main Tallyfy platform - Use email addresses from your organization's domain (if your company uses `mydomain.com`, guests can't use `mydomain.com` emails) *Important note*: You can initially assign only one guest email per task. But here's a clever feature - guests can delegate their tasks to other external people through self-delegation[^1]. Ready to start working with guests? Check out [how to assign tasks to guests](/products/pro/documenting/guests/how-can-i-assign-tasks-to-guest-users-in-tallyfy/) for the complete walkthrough. ### Guest vs Light vs Standard member comparison Understanding the differences helps you choose the right access level for each person. | Feature | Guest | Light Member | Standard Member | |---------|--------|--------------|-----------------| | **Email domain** | External only | Any domain | Any domain | | **Login access** | No (email links only) | Yes | Yes | | **Edit templates** | ❌ | ❌ | ✅ | | **Archive processes** | ❌ | ❌ | ✅ | | **Complete tasks** | ✅ | ✅ | ✅ | | **Receive notifications** | ✅ | ✅ | ✅ | | **Pre-assign in templates** | ✅ | ✅ | ✅ | | **View all processes** | ❌ | ✅ | ✅ | | **Access type** | Guest | Member | Member | | **Best for** | Clients, vendors, contractors | View-only employees | Process designers | :::note[Contractors and access considerations] **External contractors who work regularly with your organization** present an access decision. While they can be guests, guests have limitations - they can't see all processes or log in directly. If contractors need broader access or work on multiple processes regularly, they'll need Light member status. This ensures they can track their work across all assigned processes. Consider the contractor's involvement level when deciding between guest (limited access) and member (full access) status. ::: :::important[Email domain restrictions] **Guests must use external email addresses** - not your company domain. If your company uses `yourcompany.com`, you cannot assign `anyone@yourcompany.com` as a guest. They must be a Light or Standard member instead. This restriction is especially important for SSO organizations where company emails automatically require member status. ::: [^1]: Self-delegation creates a new guest_code link that can be forwarded to another external person ### Templates - **[Auto-recording steps for SOPs](https://tallyfy.com/products/pro/documenting/templates/auto-recording-steps-for-sops/)**: Free screen capture tools like Windows Steps Recorder ShareX and macOS built-in screenshot combined with Tallyfy's rich text editor provide everything needed to document procedures without paying for proprietary tools like Scribe or Trainual which lock content into their formats and only solve the easy part of capturing steps rather than tracking completion automating workflows and ensuring procedures actually get followed. ## Capturing procedures without expensive recording tools You don't need paid tools like Scribe, Trainual, or iorad to document your procedures. Free screen capture tools combined with Tallyfy's rich text editor give you everything needed to create complete step-by-step instructions. The real value isn't in capturing steps - it's in tracking completion, automating workflows, and ensuring procedures actually get followed. ### Why paid capture tools aren't necessary Services like Scribe, Trainual, or iorad lock your content into proprietary formats. Once you document a process with these tools, you're stuck paying monthly fees just to access your own procedures. Plus they only solve the easy part - capturing steps. They don't help you: - Track who completed which steps - Automate task assignments - Set deadlines and send reminders - Collect data during execution - Analyze process performance That's where Tallyfy shines. Focus on free capture, then use Tallyfy for the hard part - making procedures actually work. ## Free tools for capturing procedures ### Windows options **Steps Recorder (PSR)** - Built into Windows, automatically captures every click with screenshots and descriptions. Outputs to .MHT file which you can convert to HTML + images. - Run `psr.exe` from Start menu - Click Record, perform your steps, click Stop - Save as Web Page (HTML) to extract images - Copy step text into Tallyfy, insert extracted images **ShareX** (open-source) - Powerful screenshot and recording tool with automatic upload - Capture screenshots with annotations - Auto-upload to Imgur for instant URLs - Record GIFs for short step demonstrations - Insert images into Tallyfy using URLs or uploads **Xbox Game Bar** (Win+Alt+R) - Built-in screen recorder - Records any app window as MP4 - Upload videos directly to Tallyfy (100MB limit) - Or upload to YouTube/Vimeo and embed ### macOS options **Built-in Screenshot** (Shift-Cmd-5) - Native capture tool - Take screenshots of each step - Record screen as video - Drag images directly into Tallyfy editor **Kap** (free, open-source) - Elegant screen recorder - Export as GIF for animated steps - Export as MP4/WebM for longer procedures - Trim and optimize before importing ### Cross-platform options **OBS Studio** - Professional recording software (Windows/Mac/Linux) - Record full procedures as video - Add voiceover narration - Upload to YouTube unlisted, embed in Tallyfy **Screenity** - Chrome extension for any OS - Record browser-based procedures - Add annotations while recording - No account or time limits required ### Mobile capture **iOS Screen Recording** - Control Center feature - Swipe down, tap record button - Captures taps and swipes - Upload video to Tallyfy **Android Screen Record** - Quick Settings tile (Android 11+) - Pull down notification shade - Tap Screen Record - Save and upload to Tallyfy ## Bringing captured content into Tallyfy ### Method 1: Image-based steps (Scribe-style) Create numbered lists with screenshots for each step: 1. Capture screenshots while performing the procedure 2. In your [template](/products/pro/documenting/templates/), click **Edit** 3. For each step, type the instruction text 4. Click **Insert → Image** to add the screenshot 5. Choose upload (for local files) or URL (for hosted images) This creates clean, scannable instructions similar to paid tools but without the monthly fees. ### Method 2: Video walkthroughs Record the entire procedure as video: 1. Record using OBS, Kap, or built-in tools 2. Upload to YouTube/Vimeo as unlisted 3. In Tallyfy, click **Insert → Embed URL** 4. Paste the video URL 5. Add text descriptions for key steps below Videos work great for complex UI procedures where motion helps explain the flow. ### Method 3: Animated GIF loops Perfect for demonstrating specific interactions: 1. Use ScreenToGif (Windows) or Kap (Mac) to record 3-10 second loops 2. Export as optimized GIF 3. Insert as images in Tallyfy 4. GIFs animate automatically in the task view Short loops explain drag-and-drop, hover states, or multi-step clicks better than static images. ### Method 4: HTML content embedding If you have HTML output from tools: 1. Host the HTML on your web server 2. Use **Insert → Embed URL** to embed the content 3. Or copy text from HTML, paste into Tallyfy 4. Rebuild formatting using Tallyfy's [rich text editor](/products/pro/tracking-and-tasks/tasks/edit-task/how-can-i-use-tallyfys-rich-text-editor-for-tasks/) Note: Tallyfy strips most HTML formatting when pasting to maintain consistency. ## What makes Tallyfy different ### Beyond documentation - actual execution While capture tools stop at documentation, Tallyfy ensures procedures get done: - **Assignment automation** - Routes tasks to the right [job titles](/products/pro/documenting/templates/edit-templates/understanding-assignment-types/) or groups - **Deadline management** - Sets due dates and sends reminders - **Progress tracking** - See who's stuck and where bottlenecks occur - **Data collection** - [Form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) capture information during execution - **Conditional logic** - [Automations](/products/pro/documenting/templates/automations/) adapt procedures based on responses - **Completion verification** - Approval steps ensure quality control ### Real examples of Tallyfy vs documentation tools **Employee onboarding** - Scribe/Trainual: Static checklist with screenshots - Tallyfy: Automatically assigns IT setup to tech team, schedules training based on start date, collects equipment confirmations, tracks completion across departments **Customer support procedures** - iorad: Interactive tutorial for agents to review - Tallyfy: Routes tickets by type, escalates if SLA breached, collects resolution data, triggers follow-ups **Quality inspections** - Dozuki: Work instructions with images - Tallyfy: Enforces inspection schedule, captures defects with photos, routes issues to quality team, generates compliance reports ## Avoiding vendor lock-in ### Problems with paid documentation platforms **Scribe** - Exports only as PDF or requires paid team access. Lose interactivity and ability to update. **Trainual** - Content lives in their system. Canceling means rebuilding everything elsewhere. **iorad** - Tutorials break if UI changes. Expensive to maintain for large teams. **Dozuki** - Requires annual contracts. Migration is complex and often incomplete. **WorkRamp** - Learning content trapped in their LMS. No easy bulk export. ### Keep your content portable Store your source materials independently: - Keep original screenshots in cloud storage - Save screen recordings as standard MP4 files - Maintain text instructions in documents - Use open formats (HTML, Markdown) when possible This way you can move between platforms without losing work. ## Quick start guide ### Capture your first SOP in 10 minutes 1. **Choose your capture tool** - Windows: ShareX for screenshots or Xbox Game Bar for video - Mac: Built-in screenshot tool or Kap for recordings - Any browser: Screenity extension 2. **Perform the procedure** while capturing - Take a screenshot at each decision point - Or record the entire flow as video - Add annotations to highlight key areas 3. **Create your Tallyfy template** - Go to [Templates](/products/pro/documenting/templates/) - Click **Create New** - Add your captured content to each step 4. **Enhance with Tallyfy features** - Add [variables](/products/pro/documenting/templates/variables/) to personalize instructions - Set up [automations](/products/pro/documenting/templates/automations/) for task routing - Configure [deadline rules](/products/pro/documenting/templates/edit-templates/) for time-sensitive steps - Include [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) to collect data 5. **Test and refine** - [Launch a test process](/products/pro/launching/) - Gather feedback through comments - Update based on real usage ## Integration with existing content ### Embedding external tutorials Already have procedures hosted elsewhere? Embed them directly: - **Google Docs/Sheets**: Publish to web, embed URL - **YouTube/Vimeo videos**: Paste link into Embed URL - **Miro/Mural boards**: Share public link, embed - **Figma prototypes**: Get embed code, insert - **SharePoint pages**: If publicly accessible, embed URL ### Converting existing documentation **From Word/Google Docs**: 1. Copy text content 2. Paste into Tallyfy (formatting stripped) 3. Rebuild structure with editor tools 4. Insert images individually **From PDFs**: 1. Extract text and images using free tools 2. Recreate as structured Tallyfy steps 3. Attach original PDF as reference if needed **From wikis/knowledge bases**: 1. Export as HTML or Markdown 2. Copy section by section 3. Convert to step-based format 4. Add automation and tracking ## Best practices for procedure capture ### What to document visually vs text **Use screenshots for**: - Complex UI with many options - Specific button locations - Form field examples - Error messages - Configuration screens **Use video for**: - Multi-step sequences - Drag and drop actions - Timing-sensitive procedures - Processes with motion/animation - Verbal explanation needed **Use text only for**: - Simple linear steps - Conceptual information - Policies and rules - Decision criteria - Background context ### Optimizing file sizes Keep procedures loading fast: - Resize images to max 1920px wide - Use JPEG for photos, PNG for screenshots - Compress images with free tools (TinyPNG) - Keep videos under 5 minutes per step - Use YouTube/Vimeo for longer videos ### Maintenance and updates Make procedures easy to maintain: - Capture at lowest UI detail needed - Focus on workflow not exact pixels - Use generic examples not real data - Date your screenshots for version tracking - Link to external systems rather than duplicating ## Moving beyond documentation Documentation is just the beginning. The hard part is ensuring procedures get followed, measuring performance, and continuously improving. That's what Tallyfy does that capture tools can't: - **Launch procedures** with [kick-off forms](/products/pro/launching/triggers/kick-off-forms/) - **Track progress** in [real-time](/products/pro/tracking-and-tasks/tracker-view/) - **Analyze performance** with [Tallyfy Analytics](/products/pro/integrations/analytics/) - **Connect systems** via [API](/products/pro/integrations/open-api/) and [webhooks](/products/pro/integrations/webhooks/) - **Integrate platforms** through [middleware](/products/pro/integrations/middleware/) Stop paying for expensive documentation tools that only solve the easy part. Use free capture tools for recording steps, then use Tallyfy for what really matters - making sure work gets done right, every time. - **[Configure your template](https://tallyfy.com/products/pro/documenting/templates/config/)**: Template settings in Tallyfy allow customization of how templates function including general actions summary details organization access permissions and export options through the Settings or Config button available to Administrator members and authorized Standard members. ## Template settings Click the **Settings** button (sometimes shown as **Config**) when editing a template in Tallyfy. You'll find options to customize how your template works, who can use it, and how it's organized. :::note[Who can change template settings?] Only [Members](/products/pro/documenting/members/) with the "Administrator" role, or "Standard" members who have been given permission to edit the specific template, can change these settings. "Light" members cannot edit templates or change their settings. ::: The main areas you can configure are general actions (like copying or archiving), summary details (like descriptions and videos), organization (folders and tags), and access rules (permissions). ### General settings ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-configure-template-general-settings.png) #### Duplicate a template The duplicate button creates an exact copy of your template. Change the copy without affecting the original. Give it a new name, or it'll default to "COPY OF - [original template name]". ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-configure-template-duplicate.png) :::note[What doesn't get copied] When you duplicate a template, any tags or [webhook](/products/pro/integrations/webhooks/) settings from the original template aren't copied over to the new one. ::: #### Archive a template Archiving moves the template out of your main library. Archived templates aren't deleted. You can restore them later. #### Print a template The print function creates a version that's easy to print or save as a PDF. See [Print, Download, and Export Templates](/products/pro/documenting/templates/print-download-export-templates/). ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-configure-template-print.png) #### Organize templates into folders Move templates into specific folders to keep your library organized. See [Organize Templates into Folders](/products/pro/documenting/templates/organize-templates-into-folders/). ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-configure-template-folder.png) ### Summary settings Add details and set options that help others understand and use your template. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-configure-template-summary.png) * **Description**: Add notes explaining what the template is for. * **Status**: Set a status like "Published" or "In Progress" to show if the template is ready to use. This status shows up in the main Templates section. * **Internal explanation video URL**: Add a link (URL) to a video explaining the template. If you add a URL, a video icon appears next to the template in the Templates section for others to click. * **General information**: Shows who created the template, when it was last updated, etc. * **Force launcher to folderize [process](/products/pro/tracking-and-tasks/processes/)?**: Turn this ON to make users choose or create a folder *before* they can start a process from this template. This helps keep running processes organized. You can also pick a default folder. * **Force launcher to tag process?**: Turn this ON to make users add at least one tag (new or existing) to a process *before* they can start it. This helps categorize running processes so they're easier to find later. * **Original document**: Upload the original file (like a Word doc or PDF) that this template was based on, for reference. * **Template tags**: Add tags to this template itself to help organize your templates. * **Special instructions**: Add notes that people will see right before they [launch](/products/pro/launching/) a process from this template. Use this for important reminders or instructions. * **Webhook settings**: Set up automatic notifications to other apps when tasks in this template are completed. :::note[What are webhooks?] [Webhooks](/products/pro/integrations/webhooks/) are a way for Tallyfy to automatically send information to other web applications when something happens (like a task getting completed). ::: ### Track template activity The Activity tab shows all template changes - who made them and when. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-configure-template-activity.png) ### Control template permissions ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-configure-template-permissions.png) :::note[Important: Template visibility in Templates] For a template to be completely hidden from Standard and Light users in the Templates view, you must restrict **ALL THREE** permissions: EDIT, READ, and LAUNCH. If any of these permissions are allowed, the template will still appear in their Templates section. ::: #### Make a template publicly visible You can make templates public so anyone can see them in the [public library](/products/pro/documenting/templates/how-to-make-my-tallyfy-template-public/). #### Set template permissions Control who can edit, view, or duplicate this specific template. You can allow everyone in your organization or choose specific people or groups. **Key permission types:** - **EDIT**: Allows users to modify the template - **READ**: Allows users to view the template details - **LAUNCH**: Allows users to start new processes from the template To completely hide a template from specific Standard or Light users, ensure all three permissions are restricted for those users. #### Control process launch permissions Control who can start new [processes](/products/pro/tracking-and-tasks/processes/) using this template. You can also control who can see the running processes created from this template. You can allow everyone or choose specific people or groups. #### Configure one-off task settings You'll need to decide if people can add extra, unplanned [tasks](/products/pro/tracking-and-tasks/tasks/) to running processes. Look for the setting **"Can people add one-off tasks to this process?"** - **Yes (Default)**: Anyone involved can add extra tasks to processes launched from this template. - **No**: Only Administrators can add extra tasks. Standard and Light members cannot. Set this to **No** for processes that must strictly follow defined steps - compliance or safety procedures. ### Export options This section has the IDs for integrations or support. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-configure-template-tools.png) * **Org ID**: Your organization's unique ID. * **Template ID**: This template's unique ID. You'll need these IDs when: * Contacting Tallyfy support. * Setting up [integrations](/products/pro/integrations/) with other tools. * Copying this template to a different Tallyfy organization using the [Template Importing](/products/pro/documenting/templates/import-feature/) feature. Consultants often build templates in one organization and deploy them in another. - **[Create templates](https://tallyfy.com/products/pro/documenting/templates/create-template/)**: Tallyfy lets you create reusable process templates through three methods - building from scratch for total control or using AI assistance or uploading existing documents like Word or PDF files which get automatically optimized and restructured into trackable digital workflows. ## Creating templates in Tallyfy You create templates in Tallyfy by clicking **+Create**, then selecting from three options: start from scratch, use AI assistance, or upload an existing document. Templates are reusable blueprints - think of them like cookie cutters for your business processes. Here's the thing about templates: they're deceptively powerful. You build them once, then launch them hundreds of times. ### Why effective templates matter A solid template can significantly reduce your process time. No more explaining the same steps repeatedly to new team members. No more forgotten tasks because someone skipped a step. Everything just... works. Creating a thoughtful template takes maybe 30 minutes upfront. The payoff? Every future use of that process runs smoother. Only "Standard" members (if an Admin allows them) or "Administrator" members can create new templates. [Members](/products/pro/documenting/members/) with a "Light" role can't create templates - they can only run processes from existing ones. Want to create your first template? Here's how: Tallyfy gives you three ways to make a new template: 1. Start from scratch (blank canvas) 2. Get help from Tallyfy AI 3. Upload an existing document (like that Word SOP gathering dust on your desktop) ### Creating templates from scratch Starting from scratch means you get a blank canvas - total control over every step, every field, every automation rule. Perfect when your process is unique or has specific quirks that AI might miss. This is maximum flexibility territory. To create a template from scratch: ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-create-template-scratch.png) ### Using Tallyfy AI for template creation Not sure where to start? Let Tallyfy AI do the heavy lifting. Just describe your process - even roughly - and the AI generates a working template in seconds. Here's what actually happens: when you use Tallyfy AI (or upload a document), the AI doesn't just copy what you give it. Instead, it thinks about optimization. It'll rephrase confusing steps, cut redundant info, restructure things to work better digitally. You're getting a template designed for actual execution, not a carbon copy of your input. Smart, right? The secret to great AI templates? Be specific. Instead of "employee onboarding," try "onboard a remote software developer including laptop setup, account access, and first-week training." The AI loves details. To create a template with Tallyfy AI: ### Creating templates by uploading documents Got a Word doc or PDF with your process already written out? Perfect. Upload it, and Tallyfy AI transforms it into a living, trackable workflow. Those SOPs collecting dust in shared drives? They're about to become actually useful. Like the AI option, document uploads get the optimization treatment. The AI reads your document, then rebuilds it for digital execution - cleaning up redundancies, restructuring for clarity, making it work the way Tallyfy works. It's not making a photocopy; it's creating something better. This bridges the gap between static docs and dynamic workflows. File types that work great: - Microsoft Word (`.doc`, `.docx`) - PDF (`.pdf`) - Flowcharts (common image files might work - check the upload tool for specifics) Ready to convert that document? Here's how: ### Exact import for compliance requirements Sometimes you need every word, every comma, exactly as written - no AI interpretation allowed. Think compliance docs, legal requirements, audited SOPs. Tallyfy doesn't have a one-click "exact import" button, but there's a workaround. You'll use AI to convert your document to clean HTML first, then paste that into Tallyfy. Takes a few extra steps, but you get word-for-word accuracy. **Why bother with exact import?** - **Compliance:** Your Tallyfy template matches your approved source document character for character - **Legal Requirements:** Preserves the exact wording and structure regulations demand - **Preservation:** Creates a digital twin of your document - no AI "improvements" or rewording **Steps for Exact Import:** There you go - a word-for-word template that keeps your compliance team happy. **Video demonstration:** Want to see this in action? Here's the exact import process: ## Next steps Got your template created? Nice. Time to make it work exactly how you need it. Learn how to [edit and customize your template](/products/pro/documenting/templates/edit-templates/) - add steps, set up automation rules, create form fields. Once you've got a few templates built, [organizing them into folders](/products/pro/documenting/templates/organize-templates-into-folders/) keeps everything tidy. - **[Track activity](https://tallyfy.com/products/pro/documenting/templates/how-can-i-track-activities-on-my-tallyfy-templates/)**: Tallyfy's Activity tab provides a complete immutable history of all template changes including content modifications form field updates configuration tweaks and user actions that helps with accountability troubleshooting compliance audits and tracking workflow evolution over time. ## Tracking template activities and changes To track changes on your templates in Tallyfy, click the **Activity** tab when viewing any template - you'll see a complete history of who changed what and when. This activity log captures every modification, from simple title edits to complex automation updates. Every template automatically maintains this detailed change history. It's like having a security camera on your workflows - nothing gets modified without leaving a trace. ### Who can view template activity logs? Not everyone can peek at the activity logs - Tallyfy restricts access to: - Administrators (they can see everything) - Standard members who have permission to view that specific template - The person who originally created the template ### Why activity tracking matters Think someone accidentally broke your workflow? The activity log shows you exactly when things changed. Here's what tracking gives you: - **Complete change history**: Every single modification gets recorded. Perfect for audits. - **User accountability**: You'll know exactly who made each change - no more mystery edits - **Evolution insights**: Watch how your templates improve over time as different team members contribute their expertise - **Quick troubleshooting**: Process suddenly acting weird? Check when the last changes were made and roll back if needed - **Compliance ready**: Auditors love this stuff. You can prove exactly how your processes are controlled and who's responsible. ### What exactly gets tracked? Pretty much everything. Tallyfy captures four main categories of changes: #### Content changes - Someone renamed your template? Tracked. - Updated step descriptions to be clearer? That's in there too. - Added new steps or deleted old ones? Yep, recorded. - Modified task instructions? The log knows. #### Form field updates - New fields added to collect customer data - Validation rules tweaked (making that phone number field required) - Old fields removed when they're no longer relevant #### Configuration tweaks - Tags added or removed - Permission changes - like when you restrict access to certain team members - Webhook setups for connecting to other tools - Automation rule updates (these can really change how a workflow runs) - Template archiving and unarchiving #### User actions You'll also see when people: - Copy your template to create their own version - Publish templates to make them live - Import or export templates between organizations - Simply view the template (yes, even that gets logged) ### How to check the activity log It's straightforward - here's how you get there: 1. Head to your **Templates** library 2. Find the template you're curious about 3. Click **View** 4. Hit the **Activity** tab Done. You're looking at the complete change history. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-check-template-activity.png) ### Reading the activity log The newest changes appear at the top - just like your email inbox. Each entry shows you four key pieces of information: - **When**: Exact date and time something happened - **Who**: Which team member made the change - **What**: The type of change (edited, deleted, added, etc.) - **Details**: The specifics - what exactly they modified For instance, you might see: "March 15, 2025 at 2:47 PM - Sarah Johnson - Edited Step - Changed 'Review proposal' deadline from 2 days to 3 days." :::note[Activity timestamp display] Activity log timestamps are stored on our server in ISO 8601 format[^1] without timezone information. In the Tallyfy interface, these timestamps are automatically converted to display in your personal timezone setting, ensuring you see accurate local times while maintaining consistent data storage. ::: ### How long do logs stick around? Here's the deal with activity log storage: Activity logs last forever - well, as long as your template exists. Archive a template? The history stays intact. Need to check what happened to that old workflow from 2 years ago? It's all there. When you copy a template though, the new version starts fresh with a blank activity log. Makes sense - it's a new template with its own life story to tell. One important thing: you can't edit or delete log entries. Ever. This keeps the audit trail[^2] clean and trustworthy. ### Security note Remember - not everyone can see these logs. Tallyfy keeps them locked down to administrators, authorized team members, and the template creator. Your sensitive workflow changes stay private from prying eyes while still giving the right people the visibility they need. [^1]: Standard datetime format like YYYY-MM-DDTHH:mm:ss used for consistent timestamp storage [^2]: Immutable record of all changes required for compliance tracking and SOC 2 certification - **[Template tools](https://tallyfy.com/products/pro/documenting/templates/how-can-power-tools-enhance-my-tallyfy-experience/)**: Template Tools in Tallyfy enable bulk editing capabilities that allow users to create multiple steps simultaneously assign team members to numerous tasks at once adjust deadlines across processes and manage template favorites saving hours of manual work through batch processing features. ## Using Template Tools for faster editing Template Tools let you change multiple parts of your template at once - saving hours on what used to take forever. Think of them as your batch processing powerhouse for Tallyfy templates. No more clicking through each step individually. Ever spent an hour assigning the same person to 30 different steps? Yeah, we've all been there. ### What you need to use Template Tools - Access to edit the template you want to change - Permission to edit templates (Standard role with permission, or Administrator role) That's it. Pretty straightforward access requirements keep things secure while giving the right people the power they need. ### Accessing Template Tools 1. Open a [template](/products/pro/documenting/templates/) in edit mode. 2. Click **Settings** (or **Config**) in the toolbar at the top. 3. Click the **Tools** tab in the panel that opens. ### Bulk step creation Creating 50 steps one by one? No thanks. Bulk step creation lets you add them all at once - copy, paste, done. #### Benefits of bulk step creation - **Save time**: What takes 20 minutes manually happens in 30 seconds - **Easy copy/paste**: Got your process in a Word doc? Just paste the whole list - **Build faster**: Standard processes go from blank template to fully structured in minutes If you're building templates with more than 10 steps, this feature alone will save you hours every month. #### Using bulk step creation 1. Go to the **Tools** tab (in Template Settings). 2. Find the **Create Steps** section. 3. Type or paste your step names into the box. Put each step name on its own line. 4. Click **BUILD**. Tallyfy will add all the steps to your [template](/products/pro/documenting/templates/) in the order you listed them. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-click-powertools-create-steps.png) ### Power Builder for process conversion Already have your processes written down somewhere? Perfect. Power Builder turns your existing documentation into Tallyfy templates instantly. No starting from scratch. #### Benefits of Power Builder - **Convert existing documentation**: That 50-page procedure manual? It's now a digital workflow - **Fast template creation**: Minutes instead of hours - seriously - **No retyping needed**: Copy from Word, Excel, wherever - paste once and you're set Most companies have processes documented somewhere. Power Builder makes sure you don't waste that work. #### Using Power Builder 1. When creating a new template procedure, click on **Power Builder** in the upper right corner. 2. Type or paste your list of steps in the text area. Each step must be on its own line. 3. Click **Build Steps**. 4. Tallyfy will create all the steps in your template in the order you listed them. 5. You can then edit each step to add more details, assignments, deadlines, etc. ### Batch assignment Need Sarah to handle 15 different approval steps? Don't click 15 times. Select them all, assign once. Done. #### Benefits of batch assignment - **Faster assigning**: 20 assignments in 10 seconds beats 20 assignments in 5 minutes - **Consistency**: When the finance team owns all budget approvals, they actually get assigned to all of them - **Fewer mistakes**: Can't forget step 17 when you're selecting them all at once Batch assignment is a lifesaver when you're dealing with role-based workflows where one person or team handles multiple steps. #### Using batch assignment 1. Go to the **Tools** tab. 2. Find the **Assign Steps** section. 3. Choose the person or group ([assignee](/products/pro/documenting/members/)) from the dropdown list. 4. Check the boxes next to all the steps you want to assign to them. 5. Click **Assign**. 6. Click **APPLY** to save the assignments. *(You can also use this to unassign someone from multiple steps at once.)* ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-click-powertools-assign.png) ### Bulk deadline adjustment Your client just asked for everything to be done 2 days faster? Update all 30 deadlines in one shot instead of editing each step. #### Benefits of bulk deadline adjustment - **Manage timing**: Set consistent 24-hour deadlines across all review steps at once - **Quick updates**: Contract terms changed? Adjust every deadline in seconds - **Standard timing**: Keep your SLAs consistent without manual checking Here's the thing - deadlines change. This tool makes sure you can adapt without spending your afternoon clicking through every single step. #### Using bulk deadline adjustment 1. Go to the **Tools** tab. 2. Find the **Adjust Deadlines** section. 3. Choose if you want to add (+) or subtract (-) time. 4. Enter a number. 5. Choose the time unit (minutes, hours, days, weeks, months)[^1]. 6. Check the boxes next to all the [steps](/products/pro/tracking-and-tasks/tasks/) whose deadlines you want to change. 7. Click **UPDATE**. *Note: This tool changes deadlines based on when the process is [launched](/products/pro/launching/). It doesn't currently let you set deadlines based on when other steps are completed.* ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-click-powertools-deadlines.png) ### Template favoriting Just rolled out a new employee onboarding template? As an admin, you can add it to everyone's favorites so they actually find and use it. Smart move. #### Benefits of template favoriting - **Help people find templates**: No more "I couldn't find the right template" excuses - **Encourage use**: Put the right templates front and center - people use what they see - **New hires**: Day one, they've got all the essential processes starred and ready - **Keep people updated**: When you update that critical template, everyone watching gets notified[^2] Think of it as curating a starter pack of templates for your team. You know which ones matter - now make sure they do too. #### Using template favoriting (Administrators only) 1. Go to the **Tools** tab. 2. Find the **Favorite Template** section. 3. Type the names or email addresses of the team [members](/products/pro/documenting/members/) you want to add this template as a favorite for. Separate multiple people with commas. 4. Click **Add to Favorites**. 5. The [template](/products/pro/documenting/templates/) will now show up in those users' "Favorites" tab in their Templates section. They can then manage their own notification settings for watched templates. *Learn more about favorites in the [Favorite section guide](/products/pro/tracking-and-tasks/tracker-view/organize-processes/how-can-i-favorite-and-filter-processes-on-tallyfy/).* ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-click-powertools-favorite.png) ### Best practices for Template Tools - Always double-check your work after bulk changes - better safe than sorry - Got a standard 20-step process? Bulk step creation turns a 30-minute setup into a 2-minute task - When one person handles multiple steps (like all approvals going to a manager), batch assignment keeps everything consistent - Bulk deadline adjustments work great for time-sensitive processes - update once when requirements change instead of hunting through every step - New important template? Add it to favorites for your team before announcing it. They'll actually use it. Template Tools are powerful. Use them wisely and they'll save you hours every week. [^1]: Tallyfy deadline units are limited to these five options only for consistency [^2]: Watchers receive notifications for template updates and version changes via email - **[Sample templates](https://tallyfy.com/products/pro/documenting/templates/how-can-i-access-tallyfys-sample-templates/)**: Tallyfy offers a library of 20+ ready-made workflow templates across departments like HR Marketing Sales and IT that users can import with one click and then customize by renaming steps adjusting assignments modifying form fields and changing deadlines to match their specific team needs. ## Using Tallyfy's sample templates You can import ready-made templates from Tallyfy's library in just a few clicks - they cover everything from employee onboarding to sales processes. These templates give you a massive head start. Why build from scratch? The templates come from real companies who've refined these workflows over years. You get their best practices instantly. Just import, tweak for your team, and you're ready to go. Here's what you need to know about finding and using them. ### Benefits of sample templates Let's be honest - nobody wants to stare at a blank template. Sample templates solve that problem: - **Faster setup**: Launch your first process in minutes, not hours - **Learn best practices**: See how successful companies structure their workflows (it's like having a consultant show you what works) - **Stay consistent**: Every department uses the same proven process structure - **Understand templates**: The best way to learn? Start with working examples - **Save time**: Deploy significantly faster compared to building from zero Think of it this way: you wouldn't code a CRM from scratch when you could customize Salesforce. Same principle here. ### Finding sample templates Two places to grab templates - pick whichever's easier for you: 1. **Tallyfy's Public Template Library** - Head to [Tallyfy's Public Library](https://go.tallyfy.com/public/library) - Templates are sorted by category - HR, Marketing, you name it - Preview everything before importing (no surprises) - One click imports it straight to your account. Done. 2. **Inside Your Tallyfy Account** - Go to Templates in your dashboard - Click **Import** or **New Template** - Pick **Sample Templates** - Browse categories and grab what you need Both ways get you the same templates. The public library's great for browsing before you commit - the in-app option's faster if you know what you want. ### Available template categories #### Marketing templates - New Email Campaign for marketing communications - Facebook Ad Creation for social media advertising - Social Media Posting for content management #### HR templates - Employee Onboarding for new hire processes - Vacation Request for time-off management - Performance Review for employee evaluations #### Product management templates - Website Update Request for content changes - Product Idea Submission for innovation tracking - Feature Development Steps for product enhancement #### General office templates - Planning Regular Events for recurring activities - Daily/Weekly Team Tasks for routine operations - Weekly/Monthly Reporting for status updates #### Finance templates - Pricing Discount Approval for pricing decisions - Internal Purchase Request for procurement processes - Expense Claim Request for reimbursement workflows #### Sales templates - Sales Lead Qualification for prospect evaluation - Client Proposal Process for deal progression - Contract Review for agreement management #### IT/Support templates - Internal Support Request for help desk processes - Issue Tracking for problem resolution - Request for System Access for security management #### Onboarding templates - Tenant Onboarding (for property management) - Partner Onboarding for business relationships - Client Onboarding for customer success That's 20+ templates covering pretty much every department. If you can't find what you need here, you've got a really unique business. ### Customizing sample templates Got your template imported? Perfect. Now make it yours: ### Organizing imported templates After importing a few templates, things can get messy fast. Here's how to stay organized: - Create folders by department or process type - whatever makes sense for your team - Name templates clearly: "Employee Onboarding v2" beats "HR Process 3" - Tag everything - you'll thank yourself when you're searching through 50+ templates - Document major changes - add a note like "Added legal review step for California compliance" Trust me, spending 5 minutes organizing now saves hours of hunting later. Nothing worse than knowing you have the perfect template somewhere but can't find it. - **[Duplicate a template](https://tallyfy.com/products/pro/documenting/templates/how-do-i-duplicate-a-template-on-tallyfy/)**: Duplicating templates in Tallyfy lets you quickly create copies of existing workflow templates through the More menu which preserves all steps and settings while generating fresh IDs and requiring manual re-addition of tags and webhooks. ## Duplicating templates To duplicate a template in Tallyfy, just click the **More** menu (three dots) on any template card and select **Duplicate**. That's it. You'll have an exact copy of your [template](/products/pro/documenting/templates/) ready to customize - perfect when you need a slightly different version of a [process](/products/pro/tracking-and-tasks/processes/) or want to test changes without touching the original. :::note[Who can duplicate templates?] [Members](/products/pro/documenting/members/) with a "Light" role cannot duplicate templates. Only "Standard" members (if an Admin allows them) or "Administrator" members can duplicate templates. ::: ### What you need for duplication - Permission to access the template you want to copy - Permission to create new templates in your account - To know what gets copied and what doesn't (see below) ### Why duplicate templates? - **Save time**: Skip rebuilding similar templates from scratch - **Keep consistency**: Start with the same foundation but tweak for specific needs - **Create versions**: Different teams often need their own spin (think Sales vs. Marketing onboarding) - **Test changes safely**: Experiment on the copy - your original template in Tallyfy stays untouched - **Keep old versions**: Archive what's working while you develop something new ### Duplication process Here's how to make a copy: ### What gets copied Good news - almost everything comes along for the ride: - All the steps in the same order - Every [task](/products/pro/tracking-and-tasks/tasks/) description and instruction you wrote - All [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) and their settings - Your conditional logic (rules)[^2] and [automations](/products/pro/documenting/templates/automations/) - Task assignments (if you set them in the original template) - Any dependencies between steps (like when Step 2 waits for Step 1) - The template description ### What doesn't get copied A few things start fresh with your copy: - **Tags**: You'll need to add these again - **[Webhooks](/products/pro/integrations/webhooks/)**: These don't carry over from the original - **Internal IDs (Aliases)[^1]**: Every field and step gets brand new IDs (only matters if you've connected external tools using these specific IDs) - **History**: Your copy starts with a clean slate - no activity logs - **Template ID**: The copy gets its own unique ID in Tallyfy Simple enough. ### After duplicating Once you've made your copy, here's what to do next: [^1]: Each field gets a unique identifier like 'field_abc123' used by APIs and webhooks [^2]: If-then logic that controls task visibility, assignment, or execution based on form data - **[Convert BPMN into templates](https://tallyfy.com/products/pro/documenting/templates/how-to-convert-bpmn-patterns-into-tallyfy-templates/)**: Tallyfy simplifies BPMN conversion by letting you recreate complex process diagrams as executable step-by-step workflows through an intuitive builder that requires no technical expertise while maintaining all the logical patterns of your original BPMN design. ## Converting BPMN patterns to Tallyfy To convert BPMN diagrams into Tallyfy templates, simply recreate your process logic using Tallyfy's intuitive step-by-step builder - no technical expertise required. You'll build executable workflows that everyone can actually use. Here's the thing: many organizations have invested heavily in BPMN (Business Process Model and Notation) diagrams. They're standardized, sure. But they're also sitting in folders gathering dust. Tallyfy transforms these complex diagrams into living, breathing workflows that your team will actually follow. ### Challenges with traditional BPMN diagrams Let's be honest - BPMN diagrams can be a nightmare. You've probably experienced at least one of these frustrations: - **Complex Symbolism**: Those diamonds, circles, and gateways? Your team needs weeks of training just to read them properly - **Static Documentation**: Beautiful diagrams that just... sit there. They can't actually run anything - **Technical Barriers**: Ask your accounting team to interpret a BPMN diagram. Watch their eyes glaze over - **Modification Complexity**: Want to change a single step? Better call IT and block out half your afternoon - **Implementation Gap**: There's always that awkward moment when you realize the diagram looks nothing like how people actually work ### Advantages of Tallyfy over BPMN This is where it gets good. Tallyfy takes everything frustrating about BPMN and flips it: - **Run your processes**: Your templates become actual workflows. Launch them, track them, complete them. Done. - **No coding needed**: Forget specialized software. If you can fill out a form, you can build a process - **Easy to use**: Your entire team gets it instantly - from interns to executives - **Live updates**: Change a step? It's live immediately. No deployment cycles or version control headaches - **Built-in tracking**: See exactly where every process stands. No more "let me check on that" emails ### Tallyfy equivalents for BPMN patterns Remember those complex BPMN patterns you learned in that certification course? Tallyfy handles them all - just without the headache: | BPMN Pattern (Technical Term) | Tallyfy Implementation (How Tallyfy does it) | |-------------------------------|---------------------------------------------| | Sequential Flow | Steps happen one after another (use automation rules to enforce) | | Parallel Split (AND) | Multiple steps happen at the same time (default behavior) | | Exclusive Gateway (XOR)[^1] | Rules decide which single path to take next | | Inclusive Gateway (OR)[^2] | Rules decide which path(s) to take next | | Synchronization | Waiting for multiple steps to finish | | Structured Loop | Repeating steps within a process | | Deferred Choice | Rules decide who gets assigned a task | ### Resources for BPMN conversion Want to see exactly how to build each pattern? We've created a complete guide with real examples: [BPMN Examples and Patterns in Tallyfy](https://tallyfy.com/bpmn-examples-and-patterns) You'll find: - Step-by-step walkthroughs for every pattern (with screenshots) - Real-world examples from actual customers - Shortcuts that'll save you hours ### Steps for converting BPMN to Tallyfy Ready to make the switch? Here's your roadmap: 1. **Study your BPMN diagram** - identify the main steps, decision points, and who's responsible for what (this usually takes 10-15 minutes) 2. **Map the core logic** - what happens in sequence? Where do paths split? Simple. 3. **Create a new template** in Tallyfy 4. **Build your workflow** - add steps, assign them to the right people, and set up your automation rules. It's like building with blocks 5. **Add the details** - drop in your [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/), configure decision rules, and set up [automations](/products/pro/documenting/templates/automations/) 6. **Test run** - launch a test process and walk through it. You'll spot any issues immediately 7. **Go live** - [Launch](/products/pro/launching/) the real thing and watch your team actually follow the process The best part? You can do this entire conversion in under an hour for most processes. [^1]: XOR means eXclusive OR - only one path can be taken, mutually exclusive choices [^2]: OR allows multiple paths simultaneously, unlike XOR which forces a single choice - **[Publish a template](https://tallyfy.com/products/pro/documenting/templates/how-to-make-my-tallyfy-template-public/)**: Publishing templates in Tallyfy involves clicking Edit on your template going to Settings and switching "Public to the world" to yes which creates a shareable link allowing external stakeholders to view template structure without login while keeping all operational data private and secure. ## Publishing templates publicly To make a template public in Tallyfy, click **Edit** on your template, go to **Settings**, find **Public to the world**, and switch it to **yes**. That's it - anyone can now view your template structure[^1] without logging in. This takes under 2 minutes and gives you a shareable link for external stakeholders. ### What you need for publishing - Administrator or Standard member permissions - A complete template ready for public sharing - Understanding of what information becomes visible publicly ### Benefits of publishing templates You might be wondering why you'd want to make templates public. Here's the thing - it's actually one of the most underutilized features for growing your business: - **Share with anyone**: Give clients, partners, or vendors a direct link to view your process. No login required, no Tallyfy accounts needed - **Show examples**: Display your workflows to potential customers - nothing builds trust like transparency about how you work - **Provide documentation**: External teams can access process information instantly. Perfect for collaboration - **Enable learning**: Let others see how you've structured your processes (yes, it's okay to share your secret sauce sometimes) ### Publishing a template ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-public-template.png) ### After publishing Once your template is public, you'll get a shareable URL right in the template settings. Copy it. Now you can: - Share this link anywhere - email, chat, website, social media - Let people view the template structure without any login hassles - Track view counts in your activity log[^2] (great for seeing which templates generate the most interest) Simple. ### Security and privacy Here's what people often worry about - and it's a valid concern. What exactly are you exposing when you make a template public? - **What's public?** Only the template structure (steps, descriptions) is visible. Think of it like sharing a recipe - people can see the ingredients and instructions, but not what you cooked last Tuesday - **What's private?** All the actual data stays private. Form field responses, task completions, internal comments, who did what when - none of that shows up publicly. Your operational data is safe - **How to unpublish?** Changed your mind? No problem. Go back to settings, switch "Public to the world" to "no", and it's instantly private again The bottom line? You control exactly what's visible, and sensitive information never leaves Tallyfy. [^1]: In Tallyfy's API, templates are called 'blueprints' and include steps, fields, and routing logic [^2]: Each organization's activity feed tracks template views, task completions, and user actions with timestamps - **[Acknowledgement of changes](https://tallyfy.com/products/pro/documenting/templates/how-to-request-bulk-acknowledgement-for-template/)**: Tallyfy enables bulk acknowledgement by creating one-off tasks linked to document or procedure templates and assigning them to team members with the requirement that all assignees must complete their individual task instance before the overall task is marked as done. Need everyone to acknowledge that new policy? Create a one-off task in Tallyfy, link it to your template, and assign it to your team - everyone gets their own acknowledgement to complete. Simple. Here's the thing: This works for both [document templates](/products/pro/documenting/documents/) (like your employee handbook) and [procedure templates](/products/pro/documenting/templates/) (think quality control checklists). Same process, same peace of mind. ## Requirements for bulk acknowledgement Before you start, you'll need: - An existing [document template](/products/pro/documenting/documents/) or [procedure template](/products/pro/documenting/templates/) that needs acknowledging (can't acknowledge what doesn't exist, right?) - Permission to create tasks and assign them to members or groups in Tallyfy - usually means you're an Administrator or Standard user[^1] ## Requesting bulk acknowledgement ## The "All assignees must complete" setting Think of it like this: You've assigned the task to 50 people. With this option turned on, all 50 need to mark their individual task as complete before Tallyfy considers the whole thing done. No shortcuts. Here's what happens: - Each person gets their own copy of the task - they can't complete it for someone else - You'll see progress tracked in real-time, usually something like "23 of 50 completed" - Perfect for those situations where you absolutely need confirmation from everyone - compliance audits, safety procedures, policy updates. You know, the stuff that keeps lawyers happy. Want to dive deeper into task settings? Check out the [Advanced task options guide](/products/pro/tracking-and-tasks/tasks/how-can-i-utilize-tallyfys-advanced-tab-features/) for more tricks. Bottom line: This gives you bulletproof tracking of who's acknowledged what. No more chasing people down or wondering if everyone's actually read that critical update. Tallyfy handles the heavy lifting - you just watch the acknowledgements come in. [^1]: Standard users can create, edit and complete tasks but cannot modify system settings [^2]: Creates individual task instances for each assignee, tracked separately in the system - **[Import a template](https://tallyfy.com/products/pro/documenting/templates/import-feature/)**: Tallyfy offers multiple template import methods including AI document conversion from Word/PDF files PowerPoint playbook migration flowchart conversion from images template copying between accounts and API-based bulk operations that can convert complex documents into working workflows within seconds while maintaining structure and enabling dynamic conditional logic to replace multiple static files with single smart templates. ## Import options for templates You can import templates into Tallyfy several different ways - from Word docs, PowerPoint presentations, flowcharts, or even other Tallyfy accounts. Takes minutes, not hours. Got existing processes scattered across different formats? These import options handle them all. Whether you're migrating from another system or sharing templates between teams, Tallyfy makes the transition smooth. The best part? You don't lose your existing work. Everything transfers over. :::note[Who can import templates?] Only "Standard" [members](/products/pro/documenting/members/) (if allowed by an Admin) or "Administrator" members can import templates. "Light" members cannot. ::: ### AI document conversion Upload your Word doc or PDF, and Tallyfy's AI converts it into a working template. That 50-page SOP? Ready to use in seconds. Here's how it works: - Upload your file (Word or PDF format) - The AI reads through everything - Choose what you want: - **Document**: Creates a clean Tallyfy document with proper formatting - **Procedure**: Builds a step-by-step process template - Check the result and tweak anything you need **Time savings example**: Converting a 35-slide PowerPoint playbook takes approximately 10 seconds with AI import, compared to 2+ hours of manual copy-paste work. Convert the file to PDF first. :::note[Non-exact Import (Default)] This AI conversion is **non-exact**. The AI analyzes the document and may modify content, formatting, or structure to create an optimized Tallyfy template. It focuses on creating a functional Tallyfy process over making an exact replica of your source file. For situations requiring a verbatim copy of your source document (e.g., for compliance), see the [Exact import via AI (Manual HTML conversion)](/products/pro/documenting/templates/create-template/#exact-import-via-ai-manual-html-conversion) method described in the *Create a template* article. ::: ### Migrating PowerPoint playbooks to Tallyfy Convert your PowerPoint-based playbooks and training materials into dynamic Tallyfy templates. This feature is particularly valuable for enterprises managing dozens or hundreds of PowerPoint files that serve as operational playbooks. :::tip[Why PowerPoint users love Tallyfy] **The PowerPoint problem**: Most enterprises have 100+ similar PowerPoint files (v1, v2, v2_final, v2_final_FINAL) with slight variations for different scenarios. Finding the right version and keeping them all updated is a nightmare. **The Tallyfy solution**: One smart template with conditional logic[^2] replaces all those PowerPoint versions. What required 12 different files now becomes one dynamic template that shows only relevant content based on user selections. ::: **Quick migration process**: 1. Export your PowerPoint as PDF (maintains formatting and structure) 2. Upload the PDF to Tallyfy's AI import feature 3. Choose "Procedure" to create an interactive workflow template 4. Review and enhance with dynamic features like conditional logic **What gets converted from PowerPoint**: - Slide content becomes template steps or sections - Text boxes and tables maintain their structure - Hyperlinks are preserved as references - Visual elements like Harvey balls[^1] are interpreted into text - Slide titles become step headings - Speaker notes can be converted to step instructions **Real transformation example**: - **Before**: 47-slide PowerPoint for equipment insurance endorsements with 8 different versions for various scenarios - **After**: One Tallyfy template that asks "Equipment or Facilities?" and shows only the relevant 15-20 steps based on the answer - **Time saved**: 2 hours of manual PowerPoint editing → 10 seconds of AI import + 30 minutes of enhancement **Post-import enhancements**: After importing, transform your static PowerPoint into a dynamic workflow: - Add [conditional visibility](/products/pro/documenting/templates/automations/conditional-visibility-guide/) for different scenarios (e.g., agency vs. principal delivery) - Convert static text to dynamic dropdown fields - Apply [snippets](/products/pro/documenting/templates/snippets/) for reusable content blocks - Set up [automation rules](/products/pro/documenting/templates/automations/) for task assignments - Enable filtering to show only relevant content based on user selections - Add form fields to capture data that was previously written on printed slides **Enterprise migration strategy**: 1. **Inventory your PowerPoints**: List all operational playbooks and their variations 2. **Identify common elements**: Find sections that appear across multiple files 3. **Convert common content to snippets**: Create reusable blocks for consistency 4. **Build master templates**: Import the most complete version first 5. **Add conditional logic**: Replace multiple files with smart branching 6. **Test with users**: Ensure the dynamic template covers all scenarios 7. **Archive PowerPoints**: Keep originals for reference but stop updating them :::note[Migration success story] A professional services firm replaced 200+ PowerPoint playbooks with 15 smart Tallyfy templates. Updates that previously required editing dozens of files now happen in one place, and new employees find the right process instantly instead of searching through folders. ::: ### AI flowchart conversion Got flowcharts drawn in Visio, Lucidchart, or even on a whiteboard? Take a picture and Tallyfy turns them into live templates. The process is straightforward: - Upload a clear image of your flowchart (PNG, JPG, or PDF) - The AI reads the shapes and text - Pick your output: - **Document**: Makes a simple Tallyfy document - **Procedure**: Converts each shape into an actual workflow step - Review what it created and adjust as needed :::note[Manual setup needed for rules] The AI mainly converts the shapes into steps. You'll need to manually set up any rules (like conditional logic or [automations](/products/pro/documenting/templates/automations/)) after importing. ::: :::tip[Get better results] Use clear, high-resolution flowchart images. Easy-to-read text and clear shapes help the AI understand the steps correctly. ::: ### Copying templates between accounts Need to copy a template from one Tallyfy account to another? You can do that. Just grab two ID numbers and you're set. #### What you need for copying templates - Login access to both accounts (where it's coming from and where it's going) - Administrator permissions in the destination account #### Step 1: Get IDs from source account #### Step 2: Import into destination account #### Common reasons for copying templates - Consultants moving templates to a client's account for project delivery - Sharing standard processes between different departments or company branches for consistency - Copying templates between a test account and a live production account for safe deployment ### API import and export Developers, this one's for you. The Tallyfy API lets you manage templates with code - perfect when you're dealing with hundreds of templates or building custom integrations. What you can do: - Export templates as JSON files (great for backups) - Import templates from JSON for bulk operations - Write scripts that create and manage templates automatically Makes life easier when you're handling enterprise-scale template management. See our [GitHub repository](https://github.com/tallyfy/api-support/) for code examples and technical details. ### Best practices for Word and PowerPoint imports Importing from Word or PowerPoint? Here's what to expect: - **Purpose**: Tallyfy creates online workflows, not print-ready documents. It's built for doing, not filing. - **Formatting**: Don't panic when your fancy Word formatting disappears - Tallyfy strips it out on purpose. You'll add formatting back using Tallyfy's tools (trust us, it's better this way). - **Structure**: Use headings (H1, H2, H3) to organize content. Tallyfy automatically builds a clickable table of contents from them. - **Branding**: Your company branding gets applied automatically. No more manually formatting every single document. - **Images**: Pictures from Office files might need resizing. Quick fix in Tallyfy. - **Versions**: Remember those 100+ PowerPoint files with names like "v2_final_FINAL"? Gone. Tallyfy keeps one [master template](/products/pro/documenting/templates/master-templates-vs-processes/) with a full history log. - **Dynamic content**: Here's where it gets exciting - those 12 different PowerPoint versions become ONE template with smart branching Why the differences? Simple. Tallyfy focuses on getting work done together, not managing static files. :::tip[Best practice] Focus on getting the text content from Word into Tallyfy first - then use Tallyfy's features to format and structure it. ::: [^1]: Circular icons showing completion percentage, commonly used in PowerPoint for project status [^2]: Rules that show/hide template sections based on user input, replacing multiple static documents - **[Tags](https://tallyfy.com/products/pro/documenting/templates/how-to-manage-templates-and-processes-with-tags/)**: Tags in Tallyfy are flexible keywords that can be added to templates and processes for instant organization and filtering unlike traditional folders that limit items to single locations. ## Using tags for organization Tags in Tallyfy are keywords you can add to [templates](/products/pro/documenting/templates/) and running [processes](/products/pro/tracking-and-tasks/processes/) - think of them as flexible labels that help you find things instantly. Unlike folders where something can only live in one place, you can slap multiple tags on the same item. Here's what makes tags powerful: A single template can be tagged "HR", "Onboarding", and "High Priority" all at once. Try doing that with folders! :::note[Who can manage tags?] "Light" [members](/products/pro/documenting/members/) cannot add tags to templates. "Standard" members can add tags to templates they have permission to edit. Only "Administrators" can create, edit, or delete the shared list of tags[^1] for the whole organization. ::: ### What you need to use tags - Administrator permission (to create/edit/delete the main tag list) - Permission to edit a template or process (to add tags to it) ### Benefits of using tags - **Find things faster**: Search for templates or processes with specific tags in seconds - **Organize flexibly**: Group items in multiple ways - no more folder limitations - **See labels easily**: Color-coded tags make identification instant - **Filter lists**: Combine tags to narrow down exactly what you need in your [Tracker](/products/pro/tracking-and-tasks/tracker-view/) - **Group related processes**: See all processes for "Client Project" even if they're scattered across different folders ### Managing the organization's tag list (Admins only) If you're an administrator, you control which tags everyone in your organization can use. Here's how: ### Adding tags to templates Want to make your [templates](/products/pro/documenting/templates/) easier to find? Add tags. Takes about 30 seconds: ### Adding tags to running processes Add tags to active [processes](/products/pro/tracking-and-tasks/processes/) to categorize them while they are running: ### Filtering by tags Use tags to show only specific items in your Tallyfy dashboard: ### Tips for effective tag usage - **Use consistent names**: Decide on standard tag names (for example, always use "Human Resources" instead of sometimes using "HR") - **Keep it simple**: Stick to a manageable number of main tags (around 10-15) so the list doesn't get too confusing - **Group logically**: Create tags for useful categories like: - Department (HR, Finance, Sales) - Type of work (Approval, Review, Onboarding) - Priority (High, Medium, Low) - Status (Testing, Live, Archived) - *Note: Tallyfy has built-in status too* - **Use with folders**: Tags work well alongside folders - use folders for main structure and tags for more specific labels - **Clean up**: Occasionally review your tag list (in Settings) and delete tags that aren't needed anymore [^1]: Tags are organization-wide and synchronized across all users, unlike personal labels in some systems - **[Templates vs. processes](https://tallyfy.com/products/pro/documenting/templates/master-templates-vs-processes/)**: Master templates in Tallyfy serve as a single source of truth that generates multiple customized process instances while maintaining version control and allowing individual customization without affecting the original blueprint or other running processes. ## Single source of truth architecture ![One master template generating multiple process instances - a single dark green blueprint spawning several green customized processes, showing the one-to-many relationship](https://screenshots.tallyfy.com/illustrations/templates-vs-processes.jpeg) Master templates in Tallyfy act as your single source of truth - one authoritative version that generates customized processes. Unlike managing multiple document copies where version control becomes a nightmare, updates to the master template ensure consistency while preserving the flexibility of individual process instances. Think of it like a cookie cutter (master template) and the cookies you make (launched processes). Same shape, sure - but each cookie can have different icing, sprinkles, or decorations. ## Template to process relationship This shows how one master template spawns multiple customized processes while maintaining version independence. [Diagram removed for brevity] **Diagram description:** This diagram illustrates how a single master template generates multiple customized process instances while maintaining a continuous improvement loop. It shows the one-to-many relationship between templates and processes, with each process containing unique customizations (Client A data, Client B timeline, Client C regional rules) while feedback from all running processes flows back to improve the master template for future launches. **What to notice:** - **One-to-many relationship** - A single master template creates unlimited process instances, each with unique customizations for different clients or regions - **Version independence** - Processes launched from v1 continue unchanged even after the template updates to v2[^2], ensuring in-flight work stays consistent - **Continuous improvement loop** - Feedback from running processes helps improve future template versions without disrupting current operations ## Key distinctions explained ### Master templates (blueprints)[^1] - **Purpose**: Define the standard process structure and rules - **Editing**: Only authorized template editors can modify - **Content**: Contains placeholders, automation rules, and standard text - **Versions**: Maintains revision history for compliance - **Location**: Found in Templates section of Tallyfy ### Launched processes (active instances) - **Purpose**: Execute the actual work with real data - **Editing**: Users fill in fields and complete tasks - **Content**: Contains actual client names, dates, and specific information - **Status**: Tracks progress through active workflow - **Location**: Found in Processes section of Tallyfy ## How customization works ### At the template level You control exactly what users can and can't change when they launch a process from your template: ### At the process level Here's what happens when someone launches a process from your template: ## Real-world example - Global consulting firm **Challenge**: CBRE manages hundreds of playbooks with multiple variations: - Agency vs. Principal delivery models - Different service types (fleet, workplace, on-the-go) - Regional requirements (North America, Europe, Asia) **Traditional approach problems**: - 100+ PowerPoint files with slight variations - Manual updates to each file when standards change - Version control nightmare with local copies - No way to filter content dynamically **Tallyfy solution**: - One master template with all variations - Dynamic filtering based on user selections - Instant updates when standards change - Each launched process shows only relevant content ## Benefits over document-based systems | Traditional Documents | Tallyfy Templates | |----------------------|-------------------| | 100 copies of same SOP | 1 master template | | Manual version tracking | Automatic versioning | | Update each copy separately | Update master once | | Static content for all | Dynamic, filtered content | | Lost customizations in updates | Preserved instance data | | Email chains for status | Real-time progress tracking | | Scattered feedback | Centralized comments | ## Common misconceptions clarified ### "Can I edit the template while a process is running?" Yes - but here's the thing. Changes only affect future launched processes. Running processes continue with the version they started with. This keeps everything consistent. ### "If I update a template, will running processes break?" No. Running processes keep their original structure. Your in-flight work stays safe while you improve the template for future use. :::important[Template changes don't affect running processes] **Processes are snapshots taken at launch time**. When you launch a process from a template, it creates an independent copy with that template's structure at that moment. Adding tasks, changing steps, or modifying the template afterward won't change processes that are already running. To apply template updates, you need to launch a new process. ::: ### "Can different teams have different versions?" Forget versions - use conditional logic instead. One template shows different content based on team, region, or whatever criteria you need. ### "How do I manage 12+ variations?" Don't create 12 separate templates. Use conditional visibility and dynamic fields. One smart template replaces dozens of static documents. ## Implementation best practices ### 1. Design for reusability - Identify common elements across all variations - Use [snippets](/products/pro/documenting/templates/snippets/) for repeated content - Build in flexibility with [variables](/products/pro/documenting/templates/variables/) ### 2. Plan your customization strategy - Decide what users can change vs. what stays locked - Use form fields to capture variation needs - Set up automation rules for different paths ### 3. Test before full rollout - Launch test processes for each major variation - Verify conditional logic works correctly - Gather feedback from pilot users ### 4. Maintain the master - Regular reviews of the master template - Update based on process feedback - Version documentation for major changes ## Migration tip for enterprises Ready to move from multiple documents to Tallyfy? Here's your roadmap: ## Key takeaway Master templates give you control and standardization. Launched processes give you flexibility and customization. Simple. This architecture eliminates version control chaos while making sure everyone follows the latest approved procedures. You get both compliance and agility - no trade-offs required. [^1]: Called 'blueprints' in Tallyfy API endpoints, this technical term maps to user-facing 'templates' [^2]: Uses Git-like versioning with timeline_id and version fields to maintain process isolation - **[Milestones](https://tallyfy.com/products/pro/documenting/templates/milestones/)**: Milestones let you group template steps into collapsible sections for better organization and these sections carry through to running processes and appear in CSV exports with dedicated columns. ## Organizing steps with milestones Milestones group your [template](/products/pro/documenting/templates/) steps into collapsible sections. They're optional - steps without a milestone appear in an "unmapped" section at the bottom. ### Creating a milestone ### Managing steps in milestones - **Add steps**: Drag steps into a milestone section, or create new steps while a milestone is selected - **Move steps**: Drag between milestones, or drag to unmapped to ungroup - **Reorder milestones**: Drag milestone headers to change their order ### Renaming and deleting Right-click a milestone header to rename or delete it. Deleting a milestone moves its steps to the unmapped section. ### Milestones in running processes When you [launch a process](/products/pro/launching/), milestones carry over. [Tasks](/products/pro/tracking-and-tasks/tasks/) appear grouped under the same collapsible milestone sections. ### Milestones in exports [CSV exports](/products/pro/tracking-and-tasks/processes/how-can-i-export-tallyfy-processes-to-csv/) include `milestone_id`, `milestone_name`, and `milestone_position` columns. Tasks without a milestone show empty values. - **[Insert media](https://tallyfy.com/products/pro/documenting/templates/insert-media/)**: Tallyfy allows users to enhance task descriptions with various media types including images videos files tables and links through the Insert button in the editor toolbar making instructions clearer and more comprehensive for template users. ## Adding media to tasks You can add pictures, videos, files, tables, and links directly into task descriptions in Tallyfy templates - just click the **Insert** button in the editor toolbar. This makes your instructions crystal clear, especially when you're explaining something visual or complex. ### What you need for adding media - A template opened in edit mode - The image, video, or file you want to add (if uploading) - The web address (URL) if linking to online content ### Types of media you can add Here's what you can add to task descriptions (yes, it's quite a lot): | Media Type | How it looks | Size Limit (if uploading) | |------------|--------------|--------------------------| | Images | Shows the picture (JPG, PNG, GIF) | 100MB | | Files | Shows a link to download the file (Docs, PDFs, etc.) | 100MB | | Videos | Plays the video (uploaded or linked) | 100MB | | Links | Clickable web link | N/A | | Tables | Organizes info in rows/columns | N/A | | URLs | Shows as a clickable web link | N/A | ### Adding media to tasks Each media type works a bit differently - here's exactly how to add each one. ### Instructions for each media type #### Adding images #### Adding files #### Adding videos :::tip[Best way to add videos] Uploading videos works, but it's usually better to upload your video to YouTube or Vimeo first, then paste the link into Tallyfy. Why? Better quality, smoother playback, and it won't eat up your storage space. Use the **URL** option above or try **Embed URL** below. ::: #### Adding tables #### Adding links :::tip[Pro tip: Create email links with variables] Need users to send pre-filled emails? Check out [creating mailto: links in the rich text editor](/products/pro/tracking-and-tasks/tasks/edit-task/how-can-i-use-tallyfys-rich-text-editor-for-tasks/#how-can-i-create-one-click-email-links-using-html-mode). You can combine mailto: links with Tallyfy variables to create one-click emails with all the details already filled in. ::: #### Adding page breaks If you're editing a Document template, you can add page breaks to control where new pages start when printing or saving as PDF. Perfect for keeping related content together. #### Using Embed URL Want to show a preview of content from other websites right in your task description? That's what Embed URL does - it pulls in live content instead of just showing a link. :::tip[What can you embed?] Tallyfy works with hundreds of sites - YouTube, Vimeo, Spotify, Instagram, Twitter, Google Maps, and tons more. The embedded content stays interactive too. Much slicker than uploading files. ::: ### Best practices for using media - Use pictures to show steps that are hard to explain in words - Attach files people need to reference while doing the task - Use videos to demonstrate how something works - Keep uploaded files under 20MB[^2] if you can - they'll load faster for everyone - Always add alt text to images (helps people using screen readers) - Use tables when you've got data to organize [^1]: Alt text is required for WCAG 2.1 AA compliance and improves SEO ranking [^2]: Files larger than 20MB may cause timeout errors on slower connections (under 10 Mbps) - **[Using folders for templates](https://tallyfy.com/products/pro/documenting/templates/organize-templates-into-folders/)**: Organizing templates in Tallyfy through folders and subfolders helps teams quickly locate workflow blueprints among large libraries while keeping template organization separate from the folder system used for active running processes and tasks. ### Benefits of template folders To organize templates in Tallyfy, create folders and drag your templates into them - it's that simple. Once you've got 20 or more templates, you'll wonder how you managed without folders. Here's why: Without folders, finding the right template in a large library takes forever. With them? You can locate any workflow in seconds. Teams with 50+ templates find their workflows much faster after implementing a solid folder structure. :::note[Who can organize templates?] "Light" [members](/products/pro/documenting/members/) cannot organize templates into folders. Only "Standard" members (if allowed by an Admin) or "Administrator" members can create folders and move templates. ::: ### Templates vs. running processes Think of template folders like organizing cookie cutters in your kitchen drawer - you're sorting the tools, not the cookies you've already baked. These folders organize your reusable workflow blueprints, not the actual work that's happening right now. It's a simple but important distinction that trips up new users all the time. :::note[Important: Template Folders are Separate from Process Folders] Tallyfy has two separate folder systems: 1. **Template Folders:** Used only in the **Templates** section to organize your master templates/blueprints. 2. **Task/Process Folders:** Used in the **Tasks** and **Tracker** views to organize *running* processes and tasks. These are kept separate because how you organize your master templates might be different from how you organize your live projects. **Example 1:** You might have a template folder called "HR" containing an "Employee Onboarding" template. But when you actually run the onboarding process for new hires, you might put those running processes into folders named after the department they joined, like "Sales Team Onboarding" or "IT Team Onboarding". **Example 2:** You might store all templates related to client work in a template folder called "Client Operations". But the actual running processes for each client would likely go into process folders named after the client, like "Acme Corp Projects" or "Beta Inc Requests". ::: #### What you need for organizing templates - Access to the Templates section - At least a few templates to organize (there's no point creating folders for just one or two) - Standard or Admin permissions - Light users can't create folders That last point matters. Only team members with the right permissions can restructure your template library (which prevents chaos). #### Benefits of template folders - **Find templates faster**: A good folder structure dramatically reduces search time - **Group logically**: HR templates in one spot, sales workflows in another - whatever makes sense for your team - **Cleaner templates section**: No more scrolling through an endless list of templates - **Help your team**: New employees find what they need without asking The more templates you create, the more you'll appreciate having folders. Trust me on this one. #### Creating main folders Done. Your new folder appears instantly in the left panel. Click it to open it up or start adding templates. ![](https://screenshots.tallyfy.com/tallyfy/pro/desktop-light-point-folders-templates.png) #### Creating subfolders You'll see subfolders nested under their parent folder - nice and tidy. #### Moving templates into folders #### Managing existing folders *Important: Deleting a folder does **not** delete the templates inside it. The templates will just move back to the main library view (unfoldered).* #### Restoring archived templates When you unarchive a [template](/products/pro/documenting/templates/), Tallyfy remembers where it came from: - If the original folder still exists, that's where it goes back - If you deleted that folder? The template lands in your main library view instead #### Best practices for folder organization Keep folder names obvious - "HR Templates" beats "Human Resources Documentation and Processes" every time. You want anyone on your team to know exactly what's inside without thinking twice. Resist the urge to create endless subfolders. Two or three levels deep? Perfect. Five levels? You've built a maze nobody wants to navigate. I've seen teams create such complex structures that finding templates takes longer than before they had folders at all. Here's what works: organize by department (HR, Sales, IT) or by function (Approvals, Onboarding, Reviews). Pick one approach and stick with it. And remember - you can use tags alongside folders for extra organization. Think of folders as your main categories and tags as your subcategories. Every few months, take a look at your folder structure. Delete empty ones. Merge similar folders. Your future self will thank you. - **[Print or export templates](https://tallyfy.com/products/pro/documenting/templates/print-download-export-templates/)**: Tallyfy offers three methods to output templates - printing physical copies saving as PDFs or exporting data through the API - with each approach serving different needs from training materials to technical integrations while requiring users to switch to viewing mode before accessing print options. ## How to output templates from Tallyfy Want to get your templates out of Tallyfy? You've got three solid options: print them on paper, save them as PDFs, or export the raw data through our API[^1]. Here's the thing - each method works great for specific situations. Need a handout for tomorrow's training session? Print it. Sharing with the board? PDF's your friend. Building an integration or creating automated backups? That's where API export shines. ### What you need for outputting templates - Permission to view the template you want to output - A printer (if printing physical copies) - A PDF viewer (if saving as PDFs) - Technical knowledge or developer help (if using API export) Pretty straightforward requirements. Nothing fancy. ### Accessing templates for output To print or download a template, you need to switch to "read mode" first - the print option won't show up if you're still editing. This catches a lot of people off guard (we've all been there). **Note:** Can't see the print option? You're probably still in edit mode. Just flip that toggle to read/view mode and it'll appear. Happens to everyone. ### Printing physical copies Sometimes you just need paper. Maybe you're running a workshop with no WiFi, or your team prefers marking up physical copies. Here's how to print your templates: ### Saving as PDF documents PDFs are perfect when you need to email templates to stakeholders or keep a digital backup. The process is almost identical to printing - you just change one setting. ### API export for technical users Got a developer on your team? Or maybe you're technically savvy yourself? The API export option lets you pull template data programmatically - incredibly useful for backups or when you're moving dozens of templates at once. :::note[Template sharing between organizations] **Direct template sharing between different Tallyfy organizations isn't currently available**. If you need to share templates with other organizations or consultants, you'll need to export your template via API and have them recreate it manually. This feature is on the roadmap for future development. ::: #### What API export does - Exports everything about your template as JSON data[^2] (think of it as the raw blueprint) - Creates rock-solid backups you can restore from - Lets you automate bulk operations - imagine backing up 200 templates every night automatically Perfect for enterprise teams who need serious template management capabilities. #### Implementing API export ### Choosing the right output method Not sure which option to pick? This table breaks it down: | Method | Best Use | Format | Prerequisites | Time Required | |------------|----------------------------------------|----------|---------------|---------------| | Print | Paper copy for meetings, offline use | Paper | Printer access| 2-3 minutes | | Save as PDF| Sharing digital copy, documentation | PDF file | PDF viewer | 1-2 minutes | | API Export | Backups, moving templates, automation | JSON file| Coding skills | 5-10 minutes | Quick rule of thumb: if you're sharing with non-technical folks, go PDF. If you're doing anything programmatic, use the API. ### Troubleshooting: Can't find the print option? Still can't find that print button? Don't worry - this trips up almost everyone at first. 1. **Check your mode**: You're probably in edit mode. Look for the toggle switch at the top 2. **Switch modes**: Flip it to "View" or "Read" mode 3. **Refresh if needed**: The **Print** option should now appear in the **More** menu Why does Tallyfy hide the print option in edit mode? Simple - it prevents you from accidentally printing half-finished templates. Once you know this quirk, you'll never get stuck again. [^1]: API term 'blueprints' refers to templates in JSON format with all configuration data preserved [^2]: JavaScript Object Notation - a structured text format that preserves all template relationships and settings - **[Organizing templates](https://tallyfy.com/products/pro/documenting/templates/template-organization-best-practices/)**: Effective template organization in Tallyfy requires implementing folder structures based on departments or process types along with consistent naming conventions using prefixes and version numbers while leveraging tags for additional categorization and establishing governance frameworks that include access controls standardization requirements change management procedures and regular maintenance schedules to ensure templates remain accurate and useful. ## Template organization fundamentals Template organization in Tallyfy speeds up workflow discovery significantly. Traditional training methods fail - people [forget most of what they learn within a week](/products/pro/tutorials/why-documentation-training-fails-forgetting-curve/). Use folders, naming conventions, and governance frameworks to keep your templates organized. ### Organization strategies #### Folder structures Folder strategies that reduce template search time significantly: - **Department-based organization**: Create folders for each department (HR, Finance, Operations) - **Process type organization**: Group by process type (Approvals, Onboarding, Reviews) - **Frequency-based organization**: Separate by frequency of use (Daily, Weekly, Monthly) - **Client-based organization**: For service businesses, organize by client or client type - **Hybrid approach**: Combine methods with sub-folders (Department > Process Type) #### Naming conventions Requirements for consistent template naming: - **Be descriptive but concise**: Use clear, specific names under 60 characters for better readability in Tallyfy - **Use prefixes**: Add department or category prefixes (HR-, FIN-, OPS-) for quick identification - **Include version numbers**: Append version information when appropriate (v2.1) for change tracking - **Avoid special characters**: Stick to letters, numbers, and hyphens to prevent system issues - **Consider searchability**: Include keywords that users might search for to improve findability Example naming pattern: `[Department]-[Process Name]-[Version]` #### Tagging system Tags provide an additional organization layer beyond folders: - Keep your tags consistent across all templates - Tag things that don't fit neatly into folders (like complexity or approval type) - Common tag categories include: - **Priority**: High, Medium, Low for urgency classification - **Complexity**: Simple, Moderate, Complex for skill level requirements - **Process Stage**: Planning, Execution, Closing for workflow phases - **Approval Type**: Manager, Executive, Client for authorization levels - **Time Requirement**: Quick, Standard, Extended for duration expectations ### Process design and step granularity #### Structuring complex processes (50-100+ steps) When migrating from detailed checklists or complex procedures with many steps, consider these strategies: **Step grouping approaches**: - **Task-based grouping**: Combine related actions into single steps with checklists - Instead of: 10 separate steps for document preparation - Use: 1 step called "Prepare documents" with a 10-item checklist field[^2] - **Milestone organization**: Break long processes into logical phases - Phase 1: Research (15 steps) - Phase 2: Production (30 steps) - Phase 3: Review (20 steps) - **Responsibility clustering**: Group steps by who does them - Manager tasks (5 steps combined) - Team member tasks (8 steps combined) - External vendor tasks (3 steps combined) **When to use granular steps**: - Different people handle each step - Steps happen at different times or locations - You need separate deadlines per step - Specific approvals required between steps - Tracking individual step metrics matters **When to combine steps**: - Same person does multiple actions in sequence - Actions happen together in one sitting - Steps share the same deadline - No handoffs between actions - Steps are quick checkboxes (use checklist field instead) **Complex process example** (Blog post creation - 75 original steps): - **Before**: 75 individual steps including "Open document", "Write title", "Check spelling" - **After**: 12 consolidated steps with checklists: 1. Research topic (checklist: 8 items) 2. Create outline (checklist: 5 items) 3. Write first draft (checklist: 10 items) 4. Internal review 5. Revisions (checklist: 6 items) 6. Final editing 7. Create graphics 8. SEO optimization (checklist: 7 items) 9. Publishing setup 10. Social media preparation 11. Schedule publication 12. Post-publish checks (checklist: 5 items) ### Template governance #### Access control and permissions Control who can view, edit, and use templates: - **Template owners**: Designate specific owners responsible for each template's maintenance and updates - **Edit permissions**: Limit template editing to certain roles or individuals to prevent unauthorized changes - **Usage permissions**: Control who can launch processes from templates based on responsibility levels - **Visibility restrictions**: Make templates visible only to relevant teams to reduce clutter and improve focus - **Review requirements**: Set up approval workflows for template changes to ensure quality control :::note[Complete template hiding] To completely hide a template from Standard and Light users[^1] in the Templates section, you must restrict **ALL THREE** permissions (EDIT, READ, and LAUNCH) for those users. If any single permission remains, the template will still appear in their Templates view. ::: #### Standardization requirements Requirements for template consistency: - **Create template standards**: Define what every template must include - **Use template components**: Build reusable snippets for common elements - **Develop style guides**: Document your formatting and content rules - **Create template templates**: Start new templates from a proven base - **Regular reviews**: Check templates against your standards every quarter #### Change management process Required steps for template changes: 1. **Change request**: Write down what you want to change and why 2. **Impact assessment**: Check how this affects running processes 3. **Approval process**: Get the right people to sign off 4. **Implementation**: Make your changes 5. **Communication**: Tell everyone what changed 6. **Version control**: Keep track of all versions ### Template maintenance #### Audit schedule Quarterly template reviews should check: - **Usage analysis**: Which templates get used? Which don't? Focus on the popular ones - **Accuracy check**: Do templates match how you actually work now? - **Compliance verification**: Are you meeting all regulatory requirements? - **Duplicate identification**: Find and merge templates that do the same thing - **Orphaned template cleanup**: Archive templates nobody owns anymore #### Archive management Archive old templates instead of deleting them: - **Archive unused templates**: Move outdated templates to an archive folder - **Document archiving reasons**: Write down why you archived each one - **Set review dates**: Schedule when to check if archived templates are still needed - **Maintain access**: Keep archives available to administrators - **Create archive policies**: Decide when templates get archived (like after 6 months of no use) #### Template metrics Key metrics for template health: - **Template count**: Total number of active templates - **Template usage rate**: How often each template is used (aim for monthly use minimum) - **Template effectiveness**: Process completion rates by template (target 95%+) - **Template feedback**: User ratings and comments - **Template age**: Time since last update or review (review every 6 months) ### Organization examples #### Small business structure Basic folder structure: ``` ├── Core Operations │ ├── Client Onboarding │ ├── Project Management │ └── Invoicing ├── Internal Processes │ ├── HR │ └── Administration └── Archived Templates ``` #### Medium business structure Department-based structure: ``` ├── Sales & Marketing │ ├── Lead Management │ ├── Proposal Creation │ └── Client Onboarding ├── Operations │ ├── Project Execution │ ├── Quality Assurance │ └── Client Communications ├── Finance │ ├── Invoicing │ ├── Expense Processing │ └── Reporting ├── Human Resources │ ├── Recruitment │ ├── Employee Onboarding │ └── Performance Reviews └── Archived Templates ├── 2023 Archive └── 2022 Archive ``` #### Enterprise structure Multi-department hierarchy: ``` ├── Department 1 │ ├── Process Category A │ │ ├── Active Templates │ │ └── Under Development │ ├── Process Category B │ │ ├── Active Templates │ │ └── Under Development │ └── Department Archives ├── Department 2 │ ├── Process Category C │ │ ├── Active Templates │ │ └── Under Development │ └── Department Archives ├── Cross-Departmental │ ├── Approvals │ ├── Reviews │ └── Reporting └── Global Archives ├── 2023 Archive ├── 2022 Archive └── Legacy Systems ``` ### Management tools #### Documentation requirements Required documentation for each template: - **Purpose and scope**: What the template is for and when to use it - **Key stakeholders**: Who owns and maintains the template - **Required fields**: Which fields must be completed - **Integration points**: How the template connects with other systems - **Change history**: Record of updates and modifications #### Review schedules Template review frequencies: - **Critical templates**: Review quarterly - **Standard templates**: Review semi-annually - **Low-use templates**: Review annually - **Schedule reminders**: Set up automatic review notifications - **Document reviews**: Track who reviewed when and what changes were made [^1]: View-only users who cannot complete tasks but can see process progress [^2]: A step field type in Tallyfy that contains multiple checkbox items within a single step - **[Thinking in unit terms](https://tallyfy.com/products/pro/documenting/templates/thinking-in-unit-terms/)**: Unit-based workflow design means creating templates that handle one specific instance at a time (one employee or one invoice) rather than processing items in bulk which enables clear task ownership and precise tracking and parallel processing and perfect accountability while avoiding the common trap of unclear ownership and blocked progress that comes with bulk approaches like "process all invoices for the month." ## 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 features[^1] 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 2025" ## 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: consistently meeting deadline targets[^2] 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. ### 3. Keep related units linked 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. [^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 - **[Snippets](https://tallyfy.com/products/pro/documenting/templates/snippets/)**: Snippets are reusable text blocks that let you save frequently typed content like company addresses and legal disclaimers once and insert them anywhere while automatically updating all instances when you make changes to the original. ## Understanding snippets Snippets are reusable text blocks in Tallyfy - save them once, use them everywhere. They're perfect for content you type repeatedly, like company addresses, legal disclaimers, or standard instructions. When you update a snippet, it automatically updates everywhere you've used it. Think of it this way: you're tired of typing the same compliance disclaimer 50 times a week. Create a snippet. Done. :::tip[Snippets = Rubber Stamps or Standard Ingredients] Think of snippets in these ways: - **Rubber Stamp:** Imagine you often need to write your company address or a legal note. A snippet in Tallyfy is like creating a **rubber stamp** with that text. Instead of typing it every time, you just "stamp" the snippet where you need it. *The big advantage:* If the address changes, you update the snippet (the stamp) once. The change automatically shows up everywhere you used that stamp! - **Standard Ingredient:** Think of a common sauce or spice mix you use in many recipes. You prepare it once (create the snippet). Then, you easily add it to different recipes (templates or tasks). If you improve the sauce recipe, all dishes using it get the better version automatically. ::: ### Content you can include in snippets What can you actually put in a snippet? Pretty much any text you're sick of typing over and over: - Standard instructions for common procedures - Company policies that pop up in multiple documents - Legal disclaimers (we all have them) - Technical terms or company-specific jargon that needs exact wording - Any text you've typed more than three times this week :::important[What snippets cannot do] **Snippets are text blocks only**. They cannot contain: - **Form fields** (checkboxes, dropdowns, date pickers, etc.) - **Task structures** (assignees, deadlines, dependencies) - **Interactive elements** (buttons, links that change behavior) - **Conditional logic** (if-then rules, automation triggers) If you need reusable tasks with form fields, create a master template and copy tasks from it to other templates manually. For annually updated content like strategic objectives, include the text via snippet but ask users to specify responses in regular text areas. ::: ### Benefits of using snippets Why bother with snippets? Here's what you get: - **Consistency**: Your legal disclaimer stays exactly the same across 100 documents. No more "wait, did Sarah word this differently?" - **Efficiency**: Type it once. Use it everywhere. That's it. - **Easy Updates**: Company address changed? Update one snippet - not 47 different templates - **Standardization**: Everyone uses the approved text (yes, even Bob from accounting) - **Save Time**: Stop typing the same thing repeatedly - the time savings add up quickly ### How snippet workflow works 1. **Create** a snippet with the text you want to reuse (admins usually handle this part - keeps things tidy) 2. **Insert** the snippet anywhere using the snippet tool (✂️ icon). It's right there in your editor 3. **Update** the snippet later if needed. Change it once, and boom - it updates everywhere automatically 4. **Manage** your snippet library. Admins can clean up old ones nobody uses anymore ### Best places to use snippets Where do snippets really shine? Let me show you: - Legal notes in contracts - get that compliance wording exactly right every time - Standard operating procedures that show up in multiple workflows (you know the ones) - Company policy reminders. Same message, everywhere - Instructions that appear in different processes - why rewrite them? - Technical definitions that can't be "close enough" - Those FAQs your team asks constantly. Put the answer in a snippet - Form-filling instructions (because nobody reads them the first time anyway) - Contact info that changes every time someone gets promoted - Template references - when you need to link one template inside another, snippets make it clean Pro tip: If you've explained something twice this month, it probably needs to be a snippet. - **[Automations](https://tallyfy.com/products/pro/documenting/templates/automations/)**: Tallyfy automations turn static workflows into adaptive processes using IF-THEN rules that automatically route tasks adjust deadlines and show or hide steps based on real-time user input and form responses. ## Understanding process automations Tallyfy automations transform static workflows into intelligent processes that adapt in real-time based on user input. You'll create IF-THEN rules that automatically route tasks, adjust deadlines, and show or hide steps - each process instance follows the right path for its specific situation. Learn more about how [workflow automation](https://tallyfy.com/workflow-automation/) can streamline your operations. For AI-powered automation that can complete tasks and make decisions, see our upcoming [BYO AI integration](/products/pro/integrations/byo-ai/) that connects your existing AI subscriptions. ### How automations work Here's what makes Tallyfy automations powerful. They create smart processes that: - Ask for user input through form fields, then modify the workflow based on responses - Watch what's happening in a process (data entered, tasks completed, you name it) - Perform actions automatically when certain conditions are met - Make intelligent decisions based on captured information - Route tasks to the right people based on user input - Show or hide steps dynamically - your conditions, your rules :::tip[Think of Automations like a Thermostat] Your home thermostat follows a simple rule: **IF** the temperature goes below a set point, **THEN** turn on the heat. Tallyfy automations use the same simple "if-this-then-that" idea: - **IF** something specific happens in your process (like a form answer is 'Urgent', a task gets approved, or a deadline is missed). - **THEN** Tallyfy automatically does an action you set up (like assign a task to a manager, show a hidden step, or send an email). This lets you build workflows that adapt automatically to each unique situation. ::: :::tip[Automations: Like a "Choose Your Own Adventure" Story] Another way to think about automations is like a "choose your own adventure" story. - Just like in those stories where your choices determine the plot, your smart process asks for user input and modifies the flow based on that input - For example, if a customer selects 'Complaint' as a support ticket type (the user input), the automation can route the ticket to a specialized team and trigger a high-priority notification (the modified flow). If they select 'Feature Request', it might go to a product team backlog - This means one [template](/products/pro/documenting/templates/) handles multiple scenarios automatically, guiding each [process](/products/pro/tracking-and-tasks/processes/) down the right path based on real-time user responses ::: ### Automation rule components Every automation rule has two parts. Simple as that. #### Conditions (the "IF" part) This is your trigger - it tells the automation *when* to run. Conditions check things like: - Answers in [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) (what users actually type or select) - Whether a [task](/products/pro/tracking-and-tasks/tasks/) gets completed or approved - Time passing - maybe 3 days since a task started - What users do (or don't do) - Multiple inputs combined - this gets interesting #### Actions (the "THEN" part) Here's where the magic happens. When conditions are met, Tallyfy automatically: - **Assignment Actions**: Switches who a [task](/products/pro/tracking-and-tasks/tasks/) goes to based on user responses - **Deadline Actions**: Sets or adjusts task deadlines using user input or dates from form fields - **Status Actions**: Re-opens completed [tasks](/products/pro/tracking-and-tasks/tasks/) (perfect for approval workflows) - **Visibility Actions**: Shows or hides steps based on user input - your process adapts to each situation ### Naming automation rules Your automation names matter - they're what your team sees every day. Here's how to nail it: - **Be specific**: "Show steps for USA customers only" beats "Customer rule" every time - **Hint at the condition**: Include the trigger if you can ("Assign to manager if urgent") - **Write for others**: Your teammates should get it instantly - **Skip the generic stuff**: "Rule 1" or "Automation for step 5" won't help anyone Good names mean less confusion, faster updates, and easier troubleshooting. Worth the extra thought. ### Benefits of using automations Why bother with automations? Here's what you gain: - **Smart adaptation**: Workflows that actually listen to user input and adjust accordingly - **Rock-solid consistency**: Every process follows the same logic. No exceptions. - **Time savings**: Those routing decisions that eat up hours? Automated. - **Complexity made simple**: Sophisticated business rules run themselves - no manual juggling - **Error reduction**: Can't mis-route a task when the system handles it automatically - **Real-time flexibility**: Processes that adapt on the fly to whatever comes their way ### Getting started Explore the following sections to learn how to implement automations in Tallyfy: ### Quick examples by use case Got a specific challenge? We've got you covered: - **Customer tiers need different treatment?** → [Service level-based assignment](/products/pro/documenting/templates/automations/examples/service-level-assignment/) - **Approval chains driving you crazy?** → [Multi-level approval loops](/products/pro/documenting/templates/automations/examples/multi-level-approval-loops/) - **Racing against deadlines?** → [Countdown deadline automation](/products/pro/documenting/templates/automations/examples/countdown-deadline-automation/) - **Team members chosen at launch time?** → [Dynamic member assignment](/products/pro/documenting/templates/automations/examples/dynamic-member-assignment-from-kickoff/) - **Need steps that appear when conditions are right?** → [Combined visibility and deadline rules](/products/pro/documenting/templates/automations/examples/combined-visibility-deadline-rules/) - **[Variables](https://tallyfy.com/products/pro/documenting/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. ## Understanding variables [Variables](/products/pro/documenting/templates/variables/) in Tallyfy work like smart placeholders - they grab information from one step in your [process](/products/pro/tracking-and-tasks/processes/) and automatically show it wherever else you need it. No more copying and pasting the same data over and over. :::tip[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](/products/pro/tracking-and-tasks/tasks/) instructions mention the actual client's name, not just "the client." - **Drive automation**: Set up [automation](/products/pro/documenting/templates/automations/) 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](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) 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](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) 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](/products/pro/documenting/documents/) fill themselves out with process-specific details - Dropdown selections trigger different paths through your workflow (pick "Rush Order" and watch Tallyfy route it accordingly) [^1]: Mustache syntax for variable placeholders - double curly braces wrap the field's unique identifier - **[Edit a template](https://tallyfy.com/products/pro/documenting/templates/edit-templates/)**: Tallyfy allows template editing through the Edit icon on template cards where Standard or Administrator members can modify steps descriptions settings and other template elements in the Edit view. ## Editing templates To edit a template in Tallyfy, click the **Edit** icon (pencil) on any template card. You'll then access the Edit view where you can modify steps, descriptions, settings - basically everything about your [template](/products/pro/documenting/templates/). Simple. :::note[Who can edit templates?] [Members](/products/pro/documenting/members/) with the "Light" role **cannot** edit templates. Only "Standard" members (if an Admin gives them permission for a specific template) or "Administrator" members can edit templates. ::: Here's how to get started: 1. Go to the **Templates** library. 2. Find the template you want to change. 3. Click the **Edit** icon (the pencil) on the template card. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-open-edit-mode-template.png) This opens the **Edit view** - your command center for template modifications. You can change steps, tweak descriptions, adjust settings, and much more. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-show-template-created-by-tallyfyai.png) Want to know what specific changes you can make? The articles below cover everything in detail. ### Snippets - **[Use snippets](https://tallyfy.com/products/pro/documenting/templates/snippets/how-can-i-use-snippets-to-simplify-workflow-in-tallyfy/)**: Snippets in Tallyfy are reusable text blocks that administrators create and manage organization-wide while all users can insert them into any text editor to maintain consistency and avoid repetitive typing across templates tasks comments and other content areas. ## Creating and using snippets To use snippets in Tallyfy, click the **Snippets** icon (✂️) in any text editor and select the text block you want to insert. Snippets are reusable text blocks you create once and insert anywhere - [template](/products/pro/documenting/templates/) steps, [task](/products/pro/tracking-and-tasks/tasks/) descriptions, comments, and more. You can use snippets to avoid typing the same compliance disclaimer 50 times or to ensure everyone uses the correct phone number. ### Who can create and manage snippets? - **Administrators** create, edit, and delete snippets for the whole organization - **Everyone else** can insert existing snippets wherever they're editing text (like task descriptions or comments) ### Creating snippets (Admins only) ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-create-snippet1701483433378.png) ### Managing existing snippets (Admins only) In the Snippets settings page, you can: - View all snippets at a glance - Edit any snippet (changes update everywhere instantly[^1]) - Delete outdated snippets - Organize them into categories - "HR Policies", "Legal Disclaimers", "Contact Info", whatever makes sense for your team ### Inserting snippets into text When editing text in Tallyfy, insert a snippet by: ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-insert-snippet-in-template-example.png) ### Where can I use snippets? You can use snippets anywhere you see the text editor toolbar in Tallyfy: - Template descriptions and step descriptions - Guidance text for [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) (perfect for those "Please enter your employee ID in format XXX-XXX" instructions) - Launch instructions - those special notes people see before starting a process - Task comments when you're collaborating - Process notes - [Document template](/products/pro/documenting/documents/) content ### Embedding templates using snippets You can link to entire templates using the snippet tool. For example, if your workflow mentions "Follow the IT Security Checklist here," embed a link to that template instead of copying its content. When the checklist updates, your reference stays current. Use this for standard operating procedures, compliance checklists, or processes that connect to other processes. ### Tips for using snippets effectively **Name snippets descriptively.** Use "Legal disclaimer for contracts" instead of "Legal text 1" to find them easily later. **Keep snippets short.** A three-paragraph warranty disclaimer works well. An entire employee handbook doesn't. **Create single sources of truth.** If a support phone number appears in 12 processes, make it a snippet. Update once when it changes. **Organize with categories.** After 20+ snippets[^2], organize them into categories like "Customer Communications", "Legal Requirements", or "Technical Instructions". **Schedule reviews.** Check quarterly or biannually that snippets remain current and relevant. [^1]: Updates propagate in real-time; existing process instances retain the snippet version from launch time [^2]: The system supports unlimited snippets, but UI performance may degrade with extremely large sets ### Automations - **[Conditional visibility](https://tallyfy.com/products/pro/documenting/templates/automations/conditional-visibility-guide/)**: Conditional visibility in Tallyfy allows you to dynamically show or hide entire tasks based on form field selections using IF-THEN automation rules with AND/OR logic to create adaptive workflows where only relevant tasks appear to users. ## Understanding conditional visibility in Tallyfy You can show or hide tasks in Tallyfy based on what users select in form fields - this is conditional visibility. It creates dynamic workflows where only relevant tasks appear. Simple. **Key concept**: Conditional visibility in Tallyfy works at the task level - you can show or hide entire tasks, but not individual fields within a form. ## How conditional visibility works ### The basics Here's what happens: someone fills out a form field, Tallyfy checks your IF-THEN rules[^2], and tasks appear (or stay hidden). You can combine multiple conditions with AND/OR logic. One catch - once a task appears, it stays visible unless someone manually hides it. ### Important limitations - **No field-level conditions**: You can't show/hide individual form fields within a task (just whole tasks). Tallyfy doesn't support conditional logic at the form field level - fields can't appear/disappear based on other field values within the same form - **Tasks only**: Conditions apply to complete tasks, not sections or fields - **One-way visibility**: Tasks shown by conditions won't automatically hide if conditions change - they stick around - **Hidden steps cannot be completed**: Hidden steps remain incomplete indefinitely and can't trigger completion-based automations - **Same-step field references only**: When creating automation conditions based on form fields, you can only reference fields within the same step. You cannot reference form fields from other steps in your conditions - the dropdown will only show fields from the current step or let you check if other steps are completed/reopened :::note[Form field conditional logic not supported] **Looking for form-level conditional logic?** Tallyfy's conditional logic works at the task/step level, not within forms. You can't make form fields appear/disappear based on other field selections in the same form. Instead, use conditional task visibility to show different tasks with different form fields based on earlier selections. ::: ## Setting up conditional visibility ### Prerequisites - Administrator or Standard user role - A [template](/products/pro/documenting/templates/) with form fields - Understanding of [automation rules](/products/pro/documenting/templates/automations/) ### Basic setup steps ## Practical examples with solutions ### Example 1: Simple Yes/No branching **Scenario**: You need to show additional documentation tasks only if someone selects "International Shipping" **Setup**: ``` Kick-off form field: "Shipping Type" (Dropdown) - Options: Domestic, International Conditional task: "Customs Documentation" Rule: IF "Shipping Type" equals "International" THEN show this task ``` ### Example 1a: Agency vs. Principal delivery model **Scenario**: Service company delivers projects either as principal contractor or agency **Setup**: ``` Kick-off form field: "Delivery Model" (Dropdown) - Options: Agency, Principal Conditional tasks for Principal: - "Obtain contractor licenses" - "Set up project insurance" - "Manage subcontractor payments" Conditional tasks for Agency: - "Coordinate with client's contractors" - "Submit agency reports" - "Process agency fees" Rules: - IF "Delivery Model" equals "Principal" THEN show principal tasks - IF "Delivery Model" equals "Agency" THEN show agency tasks ``` ### Example 2: Multiple AND conditions **Scenario**: You want manager approval only for purchases over $5,000 from new vendors **Setup**: ``` Form fields: - "Purchase Amount" (Number) - "Vendor Status" (Dropdown: New, Existing) Conditional task: "Manager Approval Required" Rule: IF "Purchase Amount" is greater than 5000 AND "Vendor Status" equals "New" THEN show this task ``` **Common mistake**: People often set up separate rules instead of using AND. Don't do that! - Wrong: Two separate rules (one for amount, one for vendor) - Right: One rule with both conditions connected by AND ### Example 3: Complex OR conditions **Scenario**: Show legal review for contracts, NDA, or partnership agreements **Setup**: ``` Form field: "Document Type" (Dropdown) - Options: Contract, NDA, Partnership Agreement, Invoice, Purchase Order Conditional task: "Legal Review" Rule: IF "Document Type" equals "Contract" OR "Document Type" equals "NDA" OR "Document Type" equals "Partnership Agreement" THEN show this task ``` ### Example 4: Questionnaire-style quotation workflow **Scenario**: Build a dynamic quotation process that asks questions to narrow down options, like a decision tree **Setup**: ``` Step 1 - Kick-off form: - "Industry Type" (Dropdown: Manufacturing, Services, Retail) - "Company Size" (Radio: Small, Medium, Large) Step 2 - Manufacturing Questions (conditional): Rule: IF "Industry Type" equals "Manufacturing" THEN show this task - "Production Volume" (Number) - "Equipment Needed" (Checklist) Step 3 - Services Questions (conditional): Rule: IF "Industry Type" equals "Services" THEN show this task - "Service Type" (Dropdown) - "Monthly Hours" (Number) Step 4 - Small Business Package (conditional): Rule: IF "Company Size" equals "Small" AND "Industry Type" equals "Manufacturing" AND "Production Volume" less than 1000 THEN show this task Step 5 - Enterprise Solution (conditional): Rule: IF "Company Size" equals "Large" OR "Production Volume" greater than 10000 THEN show this task ``` **Result**: The process dynamically reveals only relevant questions based on previous answers, creating a questionnaire flow that leads to the right quotation options. :::tip[Using kick-off fields for process branching] **Want one template instead of many?** Use kick-off form fields to control your entire process flow: 1. Add dropdowns/radio buttons to your kick-off form for key decisions 2. Reference these fields in automation rules throughout the template 3. Show/hide entire task groups based on kick-off selections 4. Avoid creating duplicate templates for similar processes Example: Instead of "Onboarding - US" and "Onboarding - EU" templates, use one template with a "Region" kick-off field that controls which compliance steps appear. ::: ## Troubleshooting common issues ### Issue 1: Multiple conditional paths appearing **Problem**: User selects "Corporation", sees corporate tasks, then changes to "LLC" but corporate tasks remain visible. **Why it happens**: Tallyfy doesn't automatically hide previously shown tasks when conditions change. I know, this can be frustrating. **Solutions**: 1. **Design approach**: Use "Previous task complete" as an additional condition ``` Rule: IF "Business Type" equals "Corporation" AND "Select Business Type" is complete THEN show corporate tasks ``` 2. **Manual approach**: Train users to [manually hide tasks](/products/pro/tracking-and-tasks/tasks/manually-show-hide-tasks/) that are no longer relevant 3. **Process design**: Consider using separate templates for significantly different paths ### Issue 2: Conditions not triggering **Problem**: Tasks don't appear even when conditions are met. **Common causes and fixes**: - **Timing**: Make sure the form field is completed before the conditional task's position in the workflow - **Field references**: Double-check you're referencing the correct field name (case matters!) - **Logic errors**: Check AND vs OR usage - remember, AND requires all conditions to be true - **Data types**: Number comparisons need number fields, not text fields ### Issue 3: Hidden steps and completion conditions **Problem**: Automation rules checking "if step is complete" never trigger for hidden steps. **Why it happens**: Here's the thing - hidden steps can't be seen or completed by users. That means any automation waiting for them to be complete will wait forever. **Key points**: - Hidden steps remain incomplete indefinitely - Users can't see or complete hidden steps - Conditions like "IF Step X is complete" will never trigger if Step X is hidden - The only exception? If Step X has another rule that makes it visible first **Solutions**: 1. **Avoid dependencies on hidden step completion** - Design your workflow so completion checks only apply to visible steps 2. **Use visibility rules first** - Make steps visible before any completion-based automations depend on them 3. **Alternative conditions** - Check the original condition that would have shown the step, not its completion ### Issue 4: Too many conditions to manage **Problem**: Workflow has 20+ conditional paths making it hard to maintain. **Solution approaches**: 1. **Simplify with groups**: Instead of individual conditions, group related tasks 2. **Use sub-processes**: Launch separate processes for complex branches 3. **Redesign the flow**: Sometimes multiple simple templates work better than one complex template ## Best practices for conditional workflows ### 1. Plan before building Map out all possible paths on paper first. Seriously - grab a pen. Then identify which tasks are always needed versus conditional ones, and group related conditional tasks together. ### 2. Name strategically Your task names should hint at their conditional nature. Instead of "Corporate Filing", try "Corporate Filing Tasks (if Corporation selected)". Add notes in task descriptions about when they appear - your future self will thank you. ### 3. Test thoroughly Create test scenarios for every possible path. All of them. Then verify tasks appear in the correct order and check that parallel conditions don't conflict. ### 4. Document for users Add instructions in your kick-off form about how selections affect the workflow. Include notes in conditional tasks explaining why they appeared. And don't forget - train users on manually hiding irrelevant tasks if needed. ### 5. Maintain simplicity Here's my rule: limit condition depth (avoid conditions on conditional tasks). Use clear, binary choices when possible. Sometimes multiple simple templates work better than one complex monster. ## Advanced patterns ### Sequential conditional tasks Want conditional tasks to appear one at a time instead of all at once? Here's how: ``` Task A: "Select Option" Task B: Shows if Option = X AND Task A is complete Task C: Shows if Task B is complete AND [additional condition] ``` This keeps your workflow tidy - tasks only appear when they're actually needed. ### Conditional task groups Group related tasks that share the same condition: ``` If "Department" = "HR" then show: - Task 1: Collect employee information - Task 2: Background check - Task 3: Equipment requisition - Task 4: IT account setup ``` Set the same condition on all related tasks for consistency. ### Enterprise playbook filtering **Scenario**: You're running a global services company and need to filter playbooks based on multiple criteria: - Delivery model (agency vs. principal) - Service type (fleet, workplace, on-the-go) - Geographic requirements (North America, Europe, Asia) **Challenge**: Managing 12-14 variations without creating separate templates. Yes, it gets complex fast. **Solution approach**: **Managing complexity with 12+ variations**: - Use consistent naming patterns for easy identification - Group related tasks under section headers - Create a visibility matrix document for reference - Consider using [snippets](/products/pro/documenting/templates/snippets/) for content that appears in multiple variations - Train users on the filtering logic - they need to understand what's happening ### Default paths Always include a default path for when no conditions are met. Trust me on this one. ``` If Type = A: Show Task Set A If Type = B: Show Task Set B If Type = anything else: Show Task Set C (default) ``` ## When to avoid conditional visibility Sometimes conditional visibility isn't the answer. Consider alternatives when: - You have more than 5-6 major conditional branches - Conditions depend on multiple previous selections - Users frequently change their initial selections - Different teams handle different branches What works better? Try these instead: - Multiple specialized templates (cleaner, easier to maintain) - Using the API to launch appropriate sub-processes - Webhook integrations to external routing logic ## Future enhancement - Slides with conditional logic :::note[Coming Soon] We're building something exciting: a slides feature that makes complex conditional workflows much easier to manage. Instead of showing/hiding individual tasks, you'll create slide-based playbooks where entire slides appear based on user selections. Game-changer. **How it will work**: - Create slides with your content (think PowerPoint, but smarter) - Set IF-THEN rules at the slide level - Users answer questions at the start - Only relevant slides appear in their customized playbook **Perfect for**: - Enterprise playbooks with many variations - Training materials that adapt to roles - Compliance procedures that vary by region - Any workflow where you currently maintain multiple document versions (we've all been there) ::: [^1]: Initial form presented before a process launches, capturing key data to route workflow decisions [^2]: Automation logic format used throughout Tallyfy: IF conditions are met, THEN actions execute - **[Logic operations explained](https://tallyfy.com/products/pro/documenting/templates/automations/logic-explained/)**: Tallyfy's automation logic uses simple IF-THEN rules that watch user inputs and automatically adjust workflows based on conditions like form selections task approvals or specific requirements while combining multiple conditions with AND/OR logic to create intelligent processes that adapt to different business scenarios. ## Understanding automation logic Tallyfy's [automations](/products/pro/documenting/templates/automations/) work like smart decision-makers - they watch what users enter and automatically adjust your workflow accordingly. Simple logic rules adapt your processes to different scenarios. Nothing falls through the cracks. :::tip[Why Tallyfy uses simple logic instead of flowcharts] We chose simple "if-this-then-that" logic instead of flowcharts on purpose. Flowcharts can get very complicated and hard to understand or change, especially for big processes. Simple "if-this-then-that" rules are easy for *anyone* to understand and use, even without technical training. This approach lets you build smart processes that ask for user input and modify their flow based on responses, handling different situations automatically. ::: ### Basic "IF... THEN..." structure All [automations](/products/pro/documenting/templates/automations/) follow this basic idea: ``` IF [something is true] THEN [do this action] ``` You already think this way every day. It's natural. #### The condition (IF part) The condition is your automation's trigger - it checks what users enter and watches for specific responses. Think of it as your workflow's eyes and ears. **Examples:** - IF a user selects "Urgent" in a [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) - IF a customer chooses "Premium Service" level - IF a [task](/products/pro/tracking-and-tasks/tasks/) is approved by a manager - IF user input indicates special requirements #### The action (THEN part) Here's where the magic happens. Your process changes its behavior based on what users tell it. **Examples:** - THEN show additional steps for urgent handling - THEN assign the [task](/products/pro/tracking-and-tasks/tasks/) to a specialist team - THEN adjust deadlines based on service level - THEN hide steps that aren't relevant to this user's situation ### Combining multiple conditions Real business decisions rarely depend on just one thing. Your processes shouldn't either. Tallyfy lets you combine conditions using **AND** or **OR** - just like you'd explain rules to a colleague. #### Using AND logic AND means **ALL** conditions must be true. Everything needs to line up. ``` IF [condition 1 is true] AND [condition 2 is true] THEN [do this action] ``` **Example:** IF the user selects urgent priority (condition 1) AND the amount entered is over $1000 (condition 2) THEN modify the flow to include executive approval Makes sense, right? Big urgent requests need extra attention. #### Using OR logic OR means **AT LEAST ONE** condition needs to be true. More flexible. ``` IF [condition 1 is true] OR [condition 2 is true] THEN [do this action] ``` **Example:** IF the client selects VIP service (user input 1) OR the order amount exceeds $5000 (user input 2) THEN modify the flow to show premium processing steps Either way, they get the white-glove treatment. ### Combining AND and OR logic Now here's where it gets interesting. You might wonder - what happens when you mix AND with OR? Tallyfy keeps it simple by evaluating conditions **sequentially from left to right[^1]**, exactly in the order you add them. #### How evaluation works When you create a rule like: ``` IF [condition 1] AND [condition 2] OR [condition 3] THEN [do this action] ``` Tallyfy reads it like a sentence: 1. First checks condition 1 2. If that's true, checks condition 2 (needed for the AND) 3. If either path fails, checks condition 3 (the OR gives you another chance) The action triggers if: - Both condition 1 AND condition 2 are true, **OR** - Condition 3 is true by itself Simple. **Note:** Unlike some programming languages, Tallyfy doesn't use operator precedence (where AND would be evaluated before OR). We process conditions in the order you add them - straightforward and predictable. #### Best practice for complex logic Got really complex requirements? Don't try to cram everything into one massive rule. Break it up. Create multiple separate automation rules instead. Why? This approach: - Makes your logic clearer and easier to understand - Simplifies troubleshooting and maintenance - Avoids confusion about evaluation order Trust me on this one - your future self will thank you when you need to update these automations six months from now. ### How empty and null values affect conditions Understanding how Tallyfy evaluates empty or missing values prevents unexpected automation behavior: #### Empty field evaluation When a form field is empty or hasn't been filled yet: - **Text fields**: An empty text field is treated as "not equal" to any specific value - **Dropdowns**: No selection is considered different from any specific option - **Checkboxes**: Unchecked is evaluated as false - **Numbers**: Empty number fields don't match any numeric condition #### Common troubleshooting scenario **Problem**: A task shows up even though none of your conditions seem true. **Likely cause**: Check if you're using OR logic with "not equal" conditions. Remember: - "Field A is NOT 'Option 1'" evaluates to TRUE when the field is empty - "Field B is NOT 'Option 2'" also evaluates to TRUE when empty - With OR logic, if ANY condition is true, the action triggers **Solution**: For "not equal" conditions with empty fields, consider: 1. Making the field required so it's never empty 2. Adding an explicit check for empty values 3. Using positive conditions ("equals") instead of negative ones ("not equals") The bottom line? Tallyfy gives you the flexibility to build processes that actually think. They ask for user input at just the right moments and adapt their flow to match what's really happening in your business. [^1]: Processing order differs from standard programming operator precedence where AND typically evaluates before OR - **[Actions](https://tallyfy.com/products/pro/documenting/templates/automations/actions/)**: Automation actions in Tallyfy serve as the "THEN" component of conditional rules that automatically execute specific behaviors like task assignments deadline modifications status changes and step visibility when predefined conditions are met to streamline workflows and eliminate manual interventions. ## Understanding automation actions Actions are the "THEN" part of "if-this-then-that" [automation](/products/pro/documenting/templates/automations/) rules. When your conditions are met, actions tell Tallyfy exactly what to do - automatically. ### What you'll need - You understand basic "if-this-then-that" logic - You can edit [template](/products/pro/documenting/templates/) automations - You're familiar with your workflow processes ### Why automation actions matter Here's what actions do for you: - **Reduce manual work**: No more repeating the same assignments or toggling step visibility. - **Ensure consistency**: Your [processes](/products/pro/tracking-and-tasks/processes/) run the same way. Every time. - **Prevent errors**: Human mistakes from routine decisions? Gone. - **Speed up workflows**: Actions happen instantly - no waiting for someone to click buttons. - **Enforce business rules**: Critical policies get followed automatically (yes, even that one everyone forgets). ### The four action types Tallyfy gives you four types of actions to automate your workflows: #### Assignment actions These actions decide who's responsible for [tasks](/products/pro/tracking-and-tasks/tasks/). What you can do: - **Add assignees**: Bring more people onto a task - the current assignees stay put. - **Replace assignees**: Clear the deck and start fresh with new people. - **Clear assignees**: Remove everyone. Period. - Use an "Assignee Picker" form field to let someone else decide who gets assigned. **Example:** `IF (Office Location) is "Toronto" THEN assign task "Mentor Meeting" to "Jane Doe"` Simple. [Learn more about assignment actions](/products/pro/documenting/templates/automations/actions/asignment-actions/) Want to see this in action? - [Dynamic member assignment from kick-off forms](/products/pro/documenting/templates/automations/examples/dynamic-member-assignment-from-kickoff/) - [Service level-based task assignment](/products/pro/documenting/templates/automations/examples/service-level-assignment/) #### Deadline actions These actions automatically adjust when tasks are due. You can: - Set deadlines based on specific conditions - Push deadlines back or pull them forward - Base due dates on other steps or form field dates **Example:** `IF (Package Purchased) is "Premium" THEN shift deadline -3 days for "Send First Draft"` Premium customers get their drafts faster. Makes sense, right? [Learn more about deadline actions](/products/pro/documenting/templates/automations/actions/deadline-actions/) Real-world examples: - [Countdown deadline automation](/products/pro/documenting/templates/automations/examples/countdown-deadline-automation/) - [Combined visibility and deadline rules](/products/pro/documenting/templates/automations/examples/combined-visibility-deadline-rules/) #### Status actions These actions change a [task's](/products/pro/tracking-and-tasks/tasks/) status. Here's the main thing: they **re-open[^1]** completed tasks. That's it. When is this useful? Think approval loops. Someone reviews the work, wants changes, and boom - the task reopens for edits. It only works on tasks that are already marked complete (you can't re-open something that's not closed). **Example:** `IF (Decision) is "Requires changes" THEN re-open task "Make changes for next draft"` [Learn more about status actions](/products/pro/documenting/templates/automations/actions/status-actions/) Check out how this works in practice: - [Multi-level approval loops](/products/pro/documenting/templates/automations/examples/multi-level-approval-loops/) #### Visibility actions These control whether steps appear or stay hidden - and yes, this is the action type you'll use most. With visibility actions, you can: - Show or hide [tasks](/products/pro/tracking-and-tasks/tasks/) based on form answers - Create different process paths depending on conditions - Let processes adapt automatically to each situation **Example:** `IF (Purchase Amount) is ">$10,000" THEN SHOW "Approval by CFO" step` Big purchases need the CFO's eyes on them. Smaller ones? They skip right past. [Learn more about visibility actions](/products/pro/documenting/templates/automations/actions/visibility-actions/) See it in action: - [Combined visibility and deadline rules](/products/pro/documenting/templates/automations/examples/combined-visibility-deadline-rules/) [^1]: Status changes from completed back to in-progress, preserving task history and data - **[Conditionals](https://tallyfy.com/products/pro/documenting/templates/automations/conditionals/)**: Conditional logic in Tallyfy enables automated decision-making within processes through simple IF-THEN rules that respond to form answers step completions user roles time triggers and other conditions to create adaptive workflows while reducing manual work and ensuring consistency. ## Understanding conditional logic Conditional logic is the "IF" part of Tallyfy [automation](/products/pro/documenting/templates/automations/) rules - it's what lets your [processes](/products/pro/tracking-and-tasks/processes/) make smart decisions automatically. Think of it as teaching your workflow to handle different situations without you. :::tip[Simpler than flowcharts] You know those complex flowcharts that make your head spin? Forget them. Tallyfy's conditional logic works like simple "IF X happens..." statements that everyone on your team can actually understand and update. Same power, way less confusion. ::: ### Benefits of conditional logic - **Automate decisions**: Your workflow handles routine choices on its own - **Ensure consistency**: The same rules kick in every single time - no exceptions - **Reduce manual work**: You're not stuck making predictable decisions anymore - **Create adaptive workflows**: [Processes](/products/pro/tracking-and-tasks/processes/) that actually respond to what's happening ### Available condition types Here's what you can base your conditions on: - Answers from [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) - like "if budget exceeds $10,000" - Step status - whether something's completed, approved, or rejected - User [roles](/products/pro/documenting/members/how-do-i-manage-member-permissions-in-tallyfy/) - so managers see different tasks than team members - Time-based triggers (deadlines approaching or passed) - Process metadata - any other information about your workflow - **[Examples](https://tallyfy.com/products/pro/documenting/templates/automations/examples/)**: Complete catalog of automation examples showing practical patterns for assignment rules visibility controls deadline management approval workflows and other common business scenarios. ## Automation example catalog Looking for the exact automation pattern you need? You're in the right place. Here's our complete collection of ready-to-use Tallyfy automation examples - each one tested in real business workflows with step-by-step setup instructions. ### Assignment automations **[Automatically assign to process requestor](/products/pro/documenting/templates/automations/examples/assign-step-to-requestor/)** Need to send results back to whoever started the process? This automation captures the requestor and assigns them tasks automatically - no manual tracking needed. **[Dynamic member assignment from kick-off forms](/products/pro/documenting/templates/automations/examples/dynamic-member-assignment-from-kickoff/)** Your process launcher can pick team members right from dropdown menus. Perfect when different projects need different people. **[Service level-based task assignment](/products/pro/documenting/templates/automations/examples/service-level-assignment/)** Premium customers get premium support teams. This pattern routes tasks based on customer tier (Basic, Premium, Enterprise) or service package - automatically. ### Workflow control patterns **[Exclusive choice (pick one path)](/products/pro/documenting/templates/automations/examples/exclusive-choice/)** Sometimes your process needs to go left or right - never both. Think office employees getting IT setup while field workers get equipment training. Different paths, same process. **[Synchronization (wait for multiple approvals)](/products/pro/documenting/templates/automations/examples/synchronization/)** Can't move forward until HR and your manager both approve? This pattern makes sure all required sign-offs happen before the next step unlocks. No more chasing people. **[Multi-level approval loops](/products/pro/documenting/templates/automations/examples/multi-level-approval-loops/)** What happens when someone rejects a request? This automation sends it back for fixes, then restarts the approval chain. Smart. ### Time-based automations **[Countdown deadline automation](/products/pro/documenting/templates/automations/examples/countdown-deadline-automation/)** Meeting next Tuesday? This automation counts backwards to set deadlines - agendas go out Monday, room bookings due Friday. Works with any date you specify. **[Combined visibility and deadline rules](/products/pro/documenting/templates/automations/examples/combined-visibility-deadline-rules/)** Here's where it gets interesting: show international shipping tasks only when needed AND set their deadlines based on arrival dates. Two automations working together. ### Quick reference Not sure which example fits your workflow? We've matched common business scenarios to the right automation patterns: - **Customer support routing** → [Service level-based assignment](/products/pro/documenting/templates/automations/examples/service-level-assignment/) (premium customers, premium service) - **Purchase approvals** → [Multi-level approval loops](/products/pro/documenting/templates/automations/examples/multi-level-approval-loops/) (with automatic rejection handling) - **Event planning** → [Countdown deadline automation](/products/pro/documenting/templates/automations/examples/countdown-deadline-automation/) (everything due on time) - **Project delegation** → [Dynamic member assignment](/products/pro/documenting/templates/automations/examples/dynamic-member-assignment-from-kickoff/) (pick your team at launch) - **Compliance workflows** → [Synchronization](/products/pro/documenting/templates/automations/examples/synchronization/) (wait for all approvals) Looking for technical process patterns based on BPMN notation? Check out [BPMN Examples and Patterns](https://tallyfy.com/bpmn-examples-and-patterns). ### Actions - **[Automate task assignments](https://tallyfy.com/products/pro/documenting/templates/automations/actions/asignment-actions/)**: Assignment actions in Tallyfy automatically route tasks to the right people when specific workflow conditions are met through three options: adding assignees to existing ones replacing all current assignees with new ones or clearing all assignees entirely. ## Assignment actions explained Want [tasks](/products/pro/tracking-and-tasks/tasks/) to automatically route to the right people? That's what assignment actions do - they change who's responsible for a task when certain conditions happen in your workflow. Simple. You've got three options: - **Add assignees**: Keeps everyone who's already assigned and adds new people to the mix - **Replace assignees**: Clears out current assignees and starts fresh with only the people you specify - **Clear assignees**: Removes everyone (yes, the task becomes unassigned until someone picks it up) Here's where it gets interesting. You can assign to specific people or groups, or you can use an "Assignee Picker[^2]" [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) to let someone choose the assignee when they're filling out the form. Want both? No problem - assign the person from the field plus add their manager automatically. :::warning[Watch out for unintended assignees] Remember that tasks without assignees default to the process launcher[^1] (unless "Assign launcher automatically" is OFF). If your automation uses **"Add assignees"**, the launcher stays assigned along with your new assignees. Use **"Replace assignees"** to assign only the people you want. ::: ### Examples of assignment actions **Example 1:** Assign based on location ``` IF (Office Location field) is "Toronto" THEN Add assignee "Jane Doe" to task "Mentor Meeting" ``` What happens? When someone selects Toronto as their office, Jane automatically gets added to mentor them. The original assignee stays on too. **Example 2:** Replace assignees based on department ``` IF (Department field) is "Legal" THEN Replace all assignees for task "Contract Review" with "Legal Team" group ``` This one's different - it completely replaces whoever was assigned before. Now only the Legal Team handles contract reviews for legal department requests. **Example 3:** Using an Assignee Picker field ``` IF (Project Type field) is "Urgent" THEN Replace all assignees for task "Approval" with (Project Manager field) ``` Here you're letting someone pick the project manager in a form field. For urgent projects, that chosen person becomes the sole approver. **Example 4:** Fixing unintended launcher assignment ``` Problem: Task has no assignees → Process launcher gets it → Automation adds Kassie → Both are now assigned Solution: Use "Replace assignees" instead of "Add assignees" to assign only Kassie ``` This happens because unassigned tasks default to the launcher. "Add" keeps the launcher, "Replace" removes them. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-assignment-automation-example.png) **Important**: Don't forget the "Apply To" setting - it tells Tallyfy exactly which task step should get these new assignments. Otherwise your automation won't know where to apply the changes. [^1]: The user who initially starts a process run from a template; automatically becomes default assignee for unassigned tasks [^2]: A special form field type allowing dynamic selection of task assignees during process execution rather than pre-defining them - **[Automate deadline shifts on tasks](https://tallyfy.com/products/pro/documenting/templates/automations/actions/deadline-actions/)**: Deadline actions in Tallyfy automatically adjust task due dates based on specific conditions allowing teams to shift deadlines forward or backward link them to other steps or connect them to form field dates. ## Deadline actions Deadline actions automatically adjust task due dates in Tallyfy when specific conditions trigger them. Pretty handy, right? You'll use these to: - Shift deadlines forward or backward by a set time (like adding 3 days) - Link a deadline to another step's due date - Connect deadlines to dates your team enters in [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) Here's the key - use the "Apply To" setting in your automation rule to pick which step's deadline changes. ### Examples of deadline actions **Example 1:** Make deadline earlier for premium service ``` IF (Package Purchased field) is "Premium" THEN shift deadline for step "Send First Draft" 3 days earlier than its default ``` Premium customers get their draft 3 days sooner - simple as that. **Example 2:** Set deadline based on a meeting date ``` IF (Project Scope field) is "Complex" THEN set deadline for step "Review Meeting" to (Client Kick-off Date field) + 5 days ``` This sets your review meeting exactly 5 working days[^1] after whatever date someone entered in the "Client Kick-off Date" field. **Example 3:** Link deadlines between tasks ``` IF (Initial Review task) is completed THEN set deadline for task "Final Approval" to 2 days after the deadline of step "Client Feedback" ``` Your final approval lands 2 working days after the client feedback was due. Nice and predictable. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-deadline-automation-example.png) In this screenshot, you can see how step 13's deadline gets pushed 1 day later when the condition is met. :::note[Setting the starting point for the new deadline] When creating a deadline action, you'll pick where to start counting from. Three options: - **Current deadline**: Add or subtract from the step's original due date - **Another step's deadline**: Build off a different step's deadline - **Date field value**: Use a date someone typed into a form field Want Step B due 2 days after Step A? Easy - just set it as "+2 days from Step A's deadline". ::: :::note[How deadlines handle weekends/non-working days] Tallyfy's smart about weekends - it checks your company's working days and hours (you set these in Organization Settings). Here's what happens: if a calculated deadline falls on a weekend or outside work hours, Tallyfy **always pushes it forward** to the next working time. Never backward. Let's say a deadline lands on Saturday. Tallyfy moves it to Monday morning (assuming that's a workday for you). **Heads up**: Tallyfy uses calendar days and your configured work week only. It doesn't currently account for country holidays, company holidays, or when Bob from accounting is on vacation. Just the basic work week. Check out [Customize work week](/products/pro/settings/org-settings/how-to-adjust-task-deadlines-to-work-week/) if you need to tweak these settings. **Coming soon**: We maintain public holiday data for 200+ countries at [tallyfy.com/national-holidays](https://tallyfy.com/national-holidays/). In a future release, working day deadlines will automatically skip national holidays in your country. ::: :::tip[Calendar-based vs relative deadlines] **Need deadlines on specific days (like every Monday)?** Tallyfy deadlines are relative to when the process starts[^2], not calendar-based. For recurring workflows with specific day requirements: 1. **For weekly patterns** (Monday/Wednesday/Friday): Schedule process launches on those days, then use relative deadlines 2. **For monthly patterns** (1st of month, last day): Use scheduled process launches on those dates 3. **For accounting cycles**: Consider separate templates for different deadline patterns 4. **Variable deadlines**: Use date form fields to capture specific dates, then set deadlines relative to those dates This design ensures processes work regardless of when they're launched. ::: [^1]: Working days exclude weekends based on your Organization Settings configuration [^2]: Deadlines calculate from run creation time, not from a fixed calendar date - **[Automate changing the status of tasks](https://tallyfy.com/products/pro/documenting/templates/automations/actions/status-actions/)**: Status actions in Tallyfy automatically re-open previously completed tasks when specific conditions are met making them ideal for approval rejections and feedback loops that require returning work to earlier steps. ## Status actions explained Status actions in Tallyfy do one thing - they automatically **re-open a step ([task](/products/pro/tracking-and-tasks/tasks/)) that was already marked as complete.** That's it. Here's the catch: the task must already be complete for this to work. If it's still open or hasn't started yet? Nothing happens. You'll find status actions particularly handy for: - **Approval/Rejection steps**: When something gets rejected, the previous step automatically re-opens so corrections can be made. - **Feedback loops**: Need to send a process back for revisions? Status actions handle the return trip. ### Examples of status actions **Example 1:** Re-open task after rejection ``` IF (Approval Decision field) is "Requires changes" THEN re-open task "Make changes for next draft" ``` When reviewers request changes, that draft task opens right back up. Simple. **Example 2:** Loop back if quality check fails ``` IF (Quality Check field) is "Failed" THEN re-open task "Review product specifications" ``` This sends the process back to specification review whenever quality doesn't pass. It's like having a built-in safety net. **Example 3:** Handle document corrections ``` IF (Manager Approval field) is "Rejected" THEN re-open task "Update documentation" ``` Manager says no? The documentation task re-opens automatically - no manual intervention needed. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-statusactionexample.png) See how completing step 2 automatically re-opens step 3? That's your process loop in action. :::note[Important limitations] - Status actions can **only re-open completed tasks**. That's their one job. - They can't complete, cancel, or modify tasks that are still running (or haven't started). - Remember - if the target task isn't already complete, nothing happens at all. ::: - **[Automate hiding or showing tasks](https://tallyfy.com/products/pro/documenting/templates/automations/actions/visibility-actions/)**: Visibility actions in Tallyfy use IF-THEN logic to dynamically show or hide workflow steps based on conditions like field values or task completion status enabling you to create sequential task dependencies by hiding steps by default and revealing them through automation rules when previous steps are completed. ## Visibility actions explained Visibility actions in Tallyfy let you **Show** or **Hide** specific steps based on conditions. Think of them as smart switches - they make sure users see exactly what they need, when they need it. Nothing gets missed. ### Examples of visibility actions **Example 1:** Need CFO approval for big purchases? ``` IF (Purchase Amount field) is ">$10,000" THEN SHOW step "Approval by CFO" ``` Result: The CFO approval step pops up automatically for purchases over $10k. No more chasing signatures or wondering if you missed something. **Example 2:** Small business customers don't need enterprise-level reviews ``` IF (Customer Type field) is "Small Business" THEN HIDE step "Enterprise Security Review" ``` Result: Your small business customers skip the enterprise security review - it's hidden because they simply don't need it. The process stays clean and relevant. **Example 3:** Let the process adapt to what users tell you ``` IF (Application Type field) is "Mortgage" THEN SHOW steps "Credit Check", "Property Valuation", and "Underwriting" ``` Result: When someone selects "Mortgage", boom - all the mortgage-specific steps appear. Credit checks, property valuation, underwriting. Everything they need. Here's what it looks like in action: ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-task-completion-example-automations.png) See how completing one step makes the next one appear? That's visibility automation at work. :::note[How visibility works] - Steps are **visible by default** unless you hide them. - You can hide a step initially when building the [template](/products/pro/documenting/templates/) (just toggle it in the settings). - Use a **Hide** visibility action to make steps disappear based on conditions. - Use a **Show** visibility action to reveal hidden steps when the time is right. The beauty of this approach? Every step gets considered - it's either shown when needed or deliberately hidden when it's not. Simple. ::: :::warning[Hidden steps and completion] Here's the catch: hidden steps can't be completed. They'll sit there, incomplete, forever. If you've got an automation checking "if step is complete" on a hidden step - it won't trigger. Ever. (Unless another rule makes that step visible first.) The fix? Only create completion-based automations for steps users can actually see. Need a quick workaround? You can manually show or hide steps using the "three dots" menu on any task. ::: :::note[Default behavior: Parallel execution in procedure templates] **Important**: Procedure templates in Tallyfy show all steps at once by default. People can work on them in any order - true parallel processing[^1]. This is a fundamental design choice that significantly speeds up process completion. **Sequential vs parallel workflows**: While the default is parallel (all tasks visible simultaneously), you can enforce sequential order by hiding steps initially, then using automation rules to **show** them when previous steps complete. This gives you full control over task dependencies while maintaining the flexibility of parallel work where possible. ::: ### Hiding tasks by default in a template When you're building a [procedure template](/products/pro/documenting/templates/), all tasks show up automatically when someone launches the process. But what if you want certain tasks to stay hidden until the right moment? You'll need to hide them first. That's it. Hidden steps stay out of sight until a **Show** automation brings them back. ### Enforcing sequential task order Remember how Tallyfy shows all tasks at once? Sometimes that's not what you want. Maybe Task B shouldn't start until Task A is done. Or Task C needs to wait for Task B. Here's the thing - you can force tasks to appear in sequence. It's like creating a relay race where each runner waits for the baton[^2]. You'll use a mix of hidden tasks and **Show** visibility actions in your [automations](/products/pro/documenting/templates/automations/). Here's how to set up a simple sequence: Here's what happens: - Process starts → only Task A shows up - Complete Task A → Task B appears - Complete Task B → Task C appears Perfect sequence. No jumping ahead, no confusion. You can chain as many tasks as you need this way - 5, 10, even 20 steps in perfect order. [^1]: All visible tasks can be completed simultaneously by different assignees without waiting [^2]: Sequential dependency ensures tasks complete in order, preventing race conditions ### Conditionals - **[Conditionals (IF) explained](https://tallyfy.com/products/pro/documenting/templates/automations/conditionals/conditionals-explained/)**: Tallyfy automations use conditional logic to automatically handle tasks and decisions by checking step statuses or form field content with various operators like "contains" "is completed" or "is approved" to trigger specific actions without manual intervention. ## Understanding conditionals in automations Conditionals in Tallyfy [Automations](/products/pro/documenting/templates/automations/) let you set up "if this happens, then do that" rules - just like you'd explain them to a colleague. No more manually checking if [tasks](/products/pro/tracking-and-tasks/tasks/) are done or watching for specific form answers. The **Condition** (that's your "IF" part) tells Tallyfy what to watch for. Think of it as setting up a smart assistant who knows exactly when to take action. Once you understand how conditions work, you can automate almost any decision in your workflow. Here's the thing - what you can check depends on whether you're looking at a step's progress or what someone typed in a form. ### Step-based conditions Want to check if someone's finished a task? Or if an approval went through? That's what step-based conditions do - they monitor your workflow's progress. Different step types give you different options: - **Regular Step**: Check if it's completed. (IF Step 1 Is completed THEN...) - **Approve/Reject Step**: Check if it's approved or rejected. (IF Approval Step Is rejected THEN send it back for revision) - **Expiry Step**: Check if it's acknowledged (done on time) or expired (missed the deadline). ### Form field conditions Now here's where it gets interesting. You can actually check what people type in [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) - and take different actions based on their answers. Each field type has its own set of conditions you can check: - **Text (Short or Long) or File Upload**: Look for specific words (**Contains**), make sure certain words aren't there (**Does not contain**), or check if someone left it blank (**Is empty**/**Is not empty**) - **Table**: Search for values in specific columns (**Contains**) - **Checklist**: See which boxes are ticked. You can check if items **Are** checked, **Are not** checked, or if the selection includes specific choices (**Contain**/**Do not contain**). Need to check if any item from a list is selected? Use **Any of**. - **Dropdown**: This one's powerful - check if the selection **Is** a specific option, **Is not** something, **Contains** certain text, or even compare numeric values (**Is greater than**/**Is less than**) Simple. These conditions turn your forms into decision-making tools. Someone selects "High Priority"? Route it to management. Budget over $10,000? Trigger approval workflows automatically. :::note[Combining multiple conditions] Combine several conditions in one rule using AND/OR logic (explained in [Logic operations](/products/pro/documenting/templates/automations/logic-explained/)). This lets you create very specific triggers for sophisticated automation workflows. ::: ### Examples - **[Automatically assign a step to the original process requestor](https://tallyfy.com/products/pro/documenting/templates/automations/examples/assign-step-to-requestor/)**: This automation demonstrates how to capture the original process requestor using an assignee picker field and automatically assign them to receive final notifications or results through template automation rules that replace step assignees based on form field selections. Need to automatically notify the person who started a process? Here's how to make Tallyfy remember who kicked things off and loop back to them with results - like sending payment confirmations or completed documents straight to the original requestor. ## Use case for this automation Let's say you're running a purchase request process. Here's the typical flow: 1. Sarah from marketing submits a request for new software (she's the requestor). 2. The request bounces through approvals and finance. 3. Your accountant uploads the payment proof. 4. You want Sarah to automatically get that proof - without anyone having to remember who started this whole thing. That's the challenge, right? How do you capture Sarah's identity at the beginning and make sure she gets notified at the end? Simple. ## Prerequisites * You'll need an existing [procedure template](/products/pro/documenting/templates/) ready to go. * Get comfortable with [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) - especially the *Assignee Picker* field type (it's the star of this show). * A basic grasp of [template automations](/products/pro/documenting/templates/automations/) helps, but you'll pick it up as we go. ## Setting up this automation ## How this automation works Here's what happens behind the scenes when someone launches your process: 1. Sarah (or whoever) fills out the kick-off form and selects herself in the "Who is making this request?" field. Takes 2 seconds. 2. The process chugs along through all its steps - approvals, processing, the works. 3. When Tallyfy hits your automation rule, it checks: Did someone actually fill in that assignee picker field? 4. If yes (it's not empty), boom - the automation fires. 5. The "Replace Assignee" action swaps whoever was originally assigned to that final email step with Sarah's name from the picker field. 6. Since you set the step type to "Email - Auto Send", Tallyfy sends the email automatically at the scheduled time. No manual work needed. The beauty? Sarah gets her payment proof (or whatever you're sending) without anyone having to remember she started this process three days ago. The loop closes itself. ## Related concepts * [Assignee picker form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/#assignee-picker) - The field type that makes this whole thing work * [Automation Actions: Assignment](/products/pro/documenting/templates/automations/actions/#assignment-actions) - Other ways to manipulate task assignments * [Using variables](/products/pro/documenting/templates/variables/) - Pull data from earlier steps into your notifications * [Email step types](/products/pro/tracking-and-tasks/tasks/what-types-of-tasks-can-i-create-with-tallyfy/#email-types) - Different email options in Tallyfy --- [^1]: Pre-process form that collects initial data before a process launches from a template [^2]: Step type that sends emails automatically at scheduled times without manual intervention - **[Combined visibility and deadline rules](https://tallyfy.com/products/pro/documenting/templates/automations/examples/combined-visibility-deadline-rules/)**: Combining visibility and deadline automations in Tallyfy creates adaptive workflows where steps appear only when relevant conditions are met and automatically receive appropriate deadlines based on circumstances like shipment types contract categories or customer tiers. You can combine visibility rules with deadline rules in Tallyfy to make workflows that adapt to different situations. Here's the magic: steps appear only when you need them AND they automatically get the right deadlines based on what's happening. ## Use case for this automation Think about processes that change based on circumstances. You need this combination when: - **Shipping processes**: International shipments need customs checks - but domestic ones don't. When that customs step appears, it needs a deadline tied to the arrival date. - **Contract renewals**: A custom enterprise contract needs legal review 30 days before expiration. Standard contracts? They skip it entirely. - **Event planning**: Ordered catering? The catering arrangement task shows up with a 2-week deadline before your event. - **Customer onboarding**: Premium customers get expedited setup steps with 24-hour turnarounds instead of the standard 5-day timeline. See the pattern? Steps appear only when relevant, and when they do appear, they come with smart deadlines. ## Combining visibility and deadline automations ## Real-world examples ### Example 1: Contract renewal with type-specific deadlines Not all contracts are created equal. Custom enterprise deals need extra attention: **Step**: "Legal review for special terms" **Visibility rule**: ``` IF (Contract Type field) is "Custom Enterprise" THEN Show "Legal review for special terms" ``` **Deadline rule**: ``` IF (Contract Type field) is "Custom Enterprise" THEN Set deadline to 30 days before (Contract End Date field) ``` What happens? Custom enterprise contracts trigger a legal review 30 days before they expire. Standard contracts breeze right past this step. Simple. ### Example 2: Event planning with optional services Running an event? Only show tasks for services people actually want: **Step**: "Arrange catering service" **Visibility rule**: ``` IF (Services Requested field) contains "Catering" THEN Show "Arrange catering service" ``` **Deadline rule**: ``` IF (Services Requested field) contains "Catering" THEN Set deadline to 14 days before (Event Date field) ``` No catering requested? No task appears. Catering needed? The task shows up with a 14-day countdown to event day. Your team focuses only on what matters. ### Example 3: Customer support escalation When a critical issue hits and first-line support can't fix it, you need rapid escalation: **Step**: "Senior engineer review" **Visibility rule**: ``` IF (Issue Priority field) is "Critical" AND (Initial Resolution) is "Unsuccessful" THEN Show "Senior engineer review" ``` **Deadline rule**: ``` IF (Issue Priority field) is "Critical" THEN Set deadline to 2 hours after (Escalation Time field) ``` Here's what happens: Regular issues follow normal flow. But a critical issue that stumps support? It instantly escalates to senior engineers with a 2-hour SLA[^1]. That's how you keep customers happy. ## Advanced patterns ### Multiple conditions affecting the same step Want to get fancy? Layer multiple rules to handle complex scenarios: ``` // Visibility depends on amount AND region IF (Purchase Amount field) is greater than $10,000 AND (Region field) is "International" THEN Show "Export compliance check" // Express shipping? Tight deadline IF (Shipping Method field) is "Express" THEN Set deadline for "Export compliance check" to 1 day after process launch // Standard shipping gets more time IF (Shipping Method field) is "Standard" THEN Set deadline for "Export compliance check" to 3 days after process launch ``` ### Cascading deadline adjustments Sometimes one deadline depends on another. Here's how you chain them together: ``` // First conditional step IF (Requires Inspection field) is "Yes" THEN Show "Quality inspection" AND Set deadline to (Ship Date field) minus 3 days // Second step depends on first IF (Requires Inspection field) is "Yes" THEN Show "Inspection report filing" AND Set deadline to 1 day after "Quality inspection" deadline ``` ## Best practices Here's what works well when setting up these automations: - **Keep conditions aligned**: Match your visibility and deadline triggers. If a step shows for "International" shipments, its deadline should trigger on the same condition. - **Plan for surprises**: Give hidden steps reasonable default deadlines. You never know when someone might manually show a step. - **Document everything**: Your future self (and your team) will thank you. Explain why steps appear and how deadlines work. - **Test the weird stuff**: What happens if someone leaves a date field empty? Or changes a condition mid-process? Find out before your users do. - **Name steps clearly**: "Premium setup verification" beats "Step 3" every time - especially when steps appear conditionally. :::tip[Rule evaluation order[^2]] Tallyfy evaluates all applicable rules when conditions change. Visibility rules determine if a step appears, then deadline rules set appropriate due dates. Both types can reference the same form fields and conditions in your automation setup. ::: [^1]: Service Level Agreement - a contractual commitment to respond within specified time [^2]: Rules execute in the sequence they were created, with visibility rules processed before deadline rules - **[Countdown deadline automation](https://tallyfy.com/products/pro/documenting/templates/automations/examples/countdown-deadline-automation/)**: This content demonstrates how to set up automated countdown deadlines that work backwards from important dates to ensure preparation tasks are completed on time through date field capture task creation and automation rule configuration. You can set [task](/products/pro/tracking-and-tasks/tasks/) deadlines in Tallyfy that count backwards from important dates - like having your meeting agenda automatically due 1 day before the meeting itself. These automations work in reverse, making sure preparation tasks get done before your critical dates arrive. ## Use case for countdown deadlines Countdown deadlines help you prepare for time-sensitive events: - **Meeting preparation**: Send reminders 1 day before scheduled meetings - **Event planning**: Complete setup tasks 2 weeks before the event date - **Launch coordination**: Finish marketing materials 1 week before product launch - **Contract renewals**: Start renewal discussions 30 days before expiration - **Compliance deadlines**: Submit reports 5 days before regulatory due dates You're working backwards from a fixed date. Everything gets done on time. ## Creating countdown deadline automations ## Real-world countdown examples ### Sales funnel management **Scenario**: You need to schedule follow-up activities before a prospect meeting. **Kick-off form field**: "Scheduled meeting date" **Automation rules**: 1. **Pre-meeting research deadline**: ``` IF (Scheduled Meeting Date) exists THEN Set deadline for "Complete prospect research" to 3 days before (Scheduled Meeting Date) ``` 2. **Agenda preparation deadline**: ``` IF (Scheduled Meeting Date) exists THEN Set deadline for "Send meeting agenda" to 1 day before (Scheduled Meeting Date) ``` 3. **Day-of reminder**: ``` IF (Scheduled Meeting Date) exists THEN Set deadline for "Meeting day checklist" to 2 hours before (Scheduled Meeting Date) ``` ### Podcast publishing workflow **Scenario**: Coordinate all tasks leading up to a podcast launch. **Kick-off form field**: "Podcast launch date" **Automation rules**: 1. **Audio file deadline**: ``` IF (Launch Date) exists THEN Set deadline for "Upload final audio" to 1 week before (Launch Date) ``` 2. **Promotional content deadline**: ``` IF (Launch Date) exists THEN Set deadline for "Create social media posts" to 3 days before (Launch Date) ``` 3. **Final review deadline**: ``` IF (Launch Date) exists THEN Set deadline for "Final quality check" to 1 day before (Launch Date) ``` ### International shipping process **Scenario**: Make sure customs documentation is ready before your shipment arrives. **Step 1 fields**: - Location (dropdown): "Domestic" or "International" - Expected arrival date (date field) **Automation rules**: 1. **Show customs check for international only**: ``` IF (Location) is "International" THEN Show "Verify customs documentation" ``` 2. **Set customs deadline before arrival**: ``` IF (Location) is "International" THEN Set deadline for "Verify customs documentation" to 1 week before (Expected Arrival Date) ``` That's it - international shipments won't get stuck at customs. ## Advanced countdown patterns ### Multiple countdown deadlines from one date Want to set multiple deadlines from the same date? Here's how: ``` IF (Contract End Date) exists THEN: - Set "Initial renewal discussion" to 60 days before (Contract End Date) - Set "Prepare renewal proposal" to 45 days before (Contract End Date) - Set "Send renewal offer" to 30 days before (Contract End Date) - Set "Final negotiation" to 15 days before (Contract End Date) ``` ### Conditional countdown deadlines Different lead times based on other factors: ``` IF (Event Type) is "Small Meeting" AND (Event Date) exists THEN Set "Room setup" to 1 hour before (Event Date) IF (Event Type) is "Large Conference" AND (Event Date) exists THEN Set "Room setup" to 1 day before (Event Date) ``` ### Working hours consideration Here's something nice - Tallyfy automatically adjusts deadlines to fall within working hours[^2]. If "1 day before meeting" lands on a Sunday, the deadline shifts to Friday instead. No weekend surprises. ## Best practices - **Buffer time**: Add extra time for critical tasks (e.g., 2 days before instead of 1) - **Clear task names**: Include the timing in task names like "Send agenda (1 day before meeting)" - **Required date fields**: Make date fields required if countdown deadlines depend on them - **Fallback deadlines**: Set default deadlines in case date fields are empty - **Test calculations**: Verify deadlines calculate correctly, especially around weekends :::tip[Deadline calculation order] Tallyfy recalculates countdown deadlines at three points: 1. When the process launches (if the date field is in kick-off form) 2. When you complete a step containing the date field 3. Whenever the date field value changes Your deadlines stay accurate even if dates change mid-process. ::: [^1]: Pre-launch form that captures initial data before a process starts in Tallyfy [^2]: Working hours configured in organization settings, typically Monday-Friday business hours - **[Decision with waiting step](https://tallyfy.com/products/pro/documenting/templates/automations/examples/decision-wait-continue/)**: Tallyfy enables decision-based workflows with waiting steps by using three automations together - one for the YES path that skips waiting and shows the next step immediately and one for the NO path that shows the waiting step while hiding the next step and a third automation that triggers when the waiting step completes to reveal the next step. ## Automation Example: Decision with Waiting Step Need your process to ask "Is something ready?" and either proceed immediately or wait? This pattern handles that - but it requires three automations, not two. ### The pattern Here's what you want: - **YES** → Skip waiting, go directly to the next step - **NO** → Show a waiting step, then continue when it's done Most users create two automations (one for YES, one for NO) and stop there. That's the mistake. ### Example: Payment confirmation workflow Let's say you have three steps: 1. **Decision step**: "Has the customer paid?" (YES/NO field) 2. **Waiting step**: "Hold until payment received" (hidden by default) 3. **Confirmation step**: "Record payment evidence" (hidden by default) ### Required automations (all three are necessary) **Automation 1 - YES path** (customer already paid): ``` IF (Payment field) is "Yes" THEN HIDE "Hold until payment received" step THEN SHOW "Record payment evidence" step ``` Customer paid? Skip the waiting step, go straight to confirmation. **Automation 2 - NO path** (customer hasn't paid yet): ``` IF (Payment field) is "No" THEN SHOW "Hold until payment received" step THEN HIDE "Record payment evidence" step ``` Customer hasn't paid? Show the waiting step. Hide confirmation for now. **Automation 3 - Waiting complete** (the one people forget): ``` IF "Hold until payment received" step is Completed THEN SHOW "Record payment evidence" step ``` When the waiting step is done, show the confirmation step. :::warning[Common mistake] Most users stop after automations 1 and 2. Without automation 3, the confirmation step stays hidden forever after the waiting step is completed. The NO path never reaches the confirmation. ::: ### Why all three automations? Think about what happens with only two automations: | Scenario | What happens | |----------|--------------| | YES selected | Works fine - confirmation step appears | | NO selected | Waiting step appears, confirmation hidden | | Waiting step completed | **Nothing!** Confirmation stays hidden | Automation 3 completes the NO path. Without it, the workflow dead-ends. ### Summary When combining decisions with waiting steps: 1. Create your YES automation (skip waiting, show next step) 2. Create your NO automation (show waiting, hide next step) 3. **Don't forget**: Create a "waiting completed" automation to show the next step All three automations work together. Miss one, and the workflow breaks. - **[Dynamic member assignment from kick-off forms](https://tallyfy.com/products/pro/documenting/templates/automations/examples/dynamic-member-assignment-from-kickoff/)**: This automation enables dynamic task assignment by using assignee picker fields in kick-off forms to let process launchers select specific team members for different roles which then automatically assigns tasks to the chosen people through conditional automation rules. Want to let process launchers pick who does what? Tallyfy's assignee picker fields make it happen. You can automatically assign [tasks](/products/pro/tracking-and-tasks/tasks/) to team members based on selections made right in the kick-off form[^1] - perfect when different situations need different people. ## Use case for this automation Here's when this really shines: - A project coordinator launches a client onboarding process and picks which account manager should handle that specific client - A manager starts a new hire process and chooses the HR specialist who'll guide the onboarding (maybe Sarah for tech hires, Mike for sales roles) - Someone requests a purchase approval and nominates their assistant to help gather all the documentation The beauty here? Task assignment isn't locked into the template. It's flexible. The person launching decides who gets what work, right when they need to. ## Setting up dynamic member assignment ## Advanced patterns ### Combining member selection with other conditions Want to get fancy? You can mix assignee pickers with other conditions for really smart routing: ``` IF (Priority field) is "Urgent" AND (Senior Manager field) is not empty THEN Replace assignee(s) for "Final Approval" with (Senior Manager field) ``` This means urgent requests go straight to the senior manager you picked. Regular ones? They follow the normal approval chain. ### Multiple assignee pickers working together Sometimes different process stages need different experts. No problem - just use multiple assignee picker fields: - **Initial stages**: Goes to whoever's selected in the "Project Lead" field - **Middle stages**: Handed off to the person in "Technical Expert" field - **Final stages**: Wraps up with whoever's in "Quality Reviewer" field Each picker controls its own set of tasks. The result? A workflow that adapts completely to who's available and best suited for each part. :::tip[Best practices] - Make assignee picker fields required if tasks won't work without someone assigned (trust me, you'll thank yourself later) - Write labels that make sense to the person launching - they shouldn't have to guess what "SME Resource" means - Add help text explaining what each person will actually do - Test your automations with real scenarios. Seriously. Launch a few test processes and make sure the right people get the right work. ::: ## Related concepts - [Assignee picker form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/#assignee-picker) - [Assignment actions](/products/pro/documenting/templates/automations/actions/asignment-actions/) - [Understanding assignment types](/products/pro/documenting/templates/edit-templates/understanding-assignment-types/) [^1]: Pre-launch form that collects data before a process starts, configurable per template [^2]: IF-THEN logic that executes actions based on form data or process conditions - **[Exclusive choice](https://tallyfy.com/products/pro/documenting/templates/automations/examples/exclusive-choice/)**: Tallyfy's exclusive choice automation uses radio button form fields and conditional rules to automatically route processes down exactly one path based on user selections ensuring only relevant steps appear for each scenario like different onboarding tracks for field workers versus office workers. ## Automation Example: Exclusive Choice (Pick One Path) Want your process to take different paths based on specific conditions? You need exclusive choice automation - where only **one** path gets selected from multiple options. Simple. ![BPMN diagram showing exclusive choice gateway with Path A or Path B branching options](https://screenshots.tallyfy.com/tallyfy/pro/bpmn-exclusive-choice-gateway.png) *(This diagram shows choosing between Path A OR Path B, but not both)* Here's how it works in Tallyfy. You set up multiple [automation](/products/pro/documenting/templates/automations/) rules, each with its own condition. When someone fills out a form or completes a task, Tallyfy checks which condition matches - then runs only that specific rule. Your process follows exactly one path, not two or three. ### Example: Different Onboarding Steps Based on Role Let's say you're onboarding new employees. Field workers need safety training and equipment setup. Office workers need IT access and desk assignments. Same onboarding [process](/products/pro/tracking-and-tasks/processes/), completely different steps. Start with a step that asks for the employee's role. You'll want a **Radio Button** [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) here (since they can only pick *one* option). ![](https://screenshots.tallyfy.com/tallyfy/pro/desktop-light-role-selection.png) Now comes the interesting part. Create two separate [automation](/products/pro/documenting/templates/automations/) rules - typically using Visibility Actions[^1]: - **Rule 1:** ``` IF (Role field) is "Field worker" THEN SHOW steps [List of steps specific to Field workers] ``` ![](https://screenshots.tallyfy.com/tallyfy/pro/desktop-light-ifcompleted-automation-example.png) - **Rule 2:** ``` IF (Role field) is "Office worker" THEN SHOW steps [List of steps specific to Office workers] ``` ![](https://screenshots.tallyfy.com/tallyfy/pro/desktop-light-office-worker-exclusive-choice.png) Think about what happens next. The Role field can only have *one* value, right? That means only *one* automation rule fires. Field workers see their safety protocols and equipment checklists. Office workers see IT setup and workspace preparation. Never both. ### Summary Create separate automation rules with conditions that can't be true at the same time (like radio button selections). Your process automatically chooses the right path - no manual intervention needed. [^1]: Actions that show/hide steps based on conditions, part of Tallyfy's automation engine - **[Multi-level approval loops](https://tallyfy.com/products/pro/documenting/templates/automations/examples/multi-level-approval-loops/)**: This guide demonstrates how to create multi-level approval workflows with automatic rejection handling that sends work back to previous steps for corrections while maintaining quality control across financial approvals content publishing and contract management processes. Want approval workflows where rejections send work back for fixes? Here's how. You'll build multi-level approvals that automatically reopen previous steps when someone hits reject - keeping quality high without grinding everything to a halt. ## Use case for this automation You know those approvals that need multiple sign-offs? Multi-level loops handle them perfectly: - **Financial approvals**: Purchase requests that need manager approval, then finance approval, then executive sign-off - **Content publishing**: Draft → Editor review → Legal review → Final approval - **Contract management**: Initial draft → Department head → Legal → CFO → CEO - **Quality control**: Product inspection → Supervisor check → Quality manager sign-off Here's the magic - when someone rejects at any level, the work automatically bounces back to whoever needs to fix it. No chasing people down. ## Creating a multi-level approval workflow Here's how your multi-level approval workflow flows with automatic rejection handling: [Diagram removed for brevity] **What to notice:** - 🔄 Every rejection automatically re-opens the creation task - no manual tracking needed - 🎯 Later approvals only show after earlier ones pass (visibility rules[^1] control this) - 💡 COO rejection can re-open multiple steps simultaneously for faster corrections ## Advanced approval patterns ### Conditional approval routing Need different approvers for different amounts? You can route based on any criteria: ``` IF (Purchase Amount) is greater than $50,000 AND (Manager review) is Approved THEN Show "Board approval required" ``` ### Parallel approvals with synchronization What if legal, compliance, and finance all need to review at the same time? Here's how parallel approvals work: [Diagram removed for brevity] **What to notice:** - 🚀 All three approvals trigger simultaneously after initial review - ⏸️ Final step waits until ALL parallel approvals complete - ❌ Any rejection sends the whole thing back to start Easy setup with visibility rules: ``` IF (Initial review) is Completed THEN Show "Legal approval" AND Show "Compliance approval" AND Show "Finance approval" ``` Wait for everyone to approve before moving on: ``` IF (Legal approval) is Approved AND (Compliance approval) is Approved AND (Finance approval) is Approved THEN Show "Final implementation" ``` ### Escalation paths Approvals getting stuck? Here's your fix: 1. Set the initial approval deadline 2. Create an escalation step assigned to senior management 3. Use deadline automation to trigger escalation When time's up, Tallyfy bumps it to the boss. Done. ## Best practices for approval loops Want your approval loops to actually work? Follow these: - **Clear rejection reasons**: Add comment fields so reviewers explain what needs fixing. Nobody likes guessing why their work got rejected - **Notification setup**: Turn on email notifications - people need to know when tasks bounce back to them - **Loop limits**: Think about adding a counter. After 3 rejections, maybe it's time for a meeting instead - **Documentation**: Put clear instructions in each step. Tell people exactly what you're looking for - **Audit trail**: Good news - Tallyfy tracks every approval and rejection automatically. CYA built right in :::note[Understanding re-open behavior] When a task is reopened in Tallyfy: - Its status changes from "Completed" back to "Active" - Original assignees are notified - Any data entered previously remains intact - The task appears again in the assignee's active tasks ::: ## Real-world example: Property listing approval Let me show you how a real estate agency nailed their listing approvals: [Diagram removed for brevity] **The magic here:** - 📸 Marketing rejection = agent gets specific feedback on photos - 📋 Compliance issues = both agent AND manager get notified - ✅ Every listing hits the market looking perfect Every listing hits the market looking perfect. Agents know exactly what to fix when something's off. No more "please see me" sticky notes. [^1]: Tallyfy feature that controls when steps appear based on conditions like prior task completion [^2]: Automation that triggers actions when a task changes status, like reopening steps on rejection - **[Notify the requestor when process completes](https://tallyfy.com/products/pro/documenting/templates/automations/examples/notify-requestor-on-completion/)**: Learn how to automatically notify the original process requestor when a workflow completes by capturing their identity at launch and using automations to send completion notifications with results or confirmations. ## Automatically notify the process requestor upon completion To notify someone when their process completes, capture who launched it using an assignee picker field, then use automation rules to send them the final notification. That's it. This keeps everyone in the loop - the person who started a process always knows when it's done, what happened, and gets any deliverables automatically. No more chasing people down for status updates. ### Common use cases You'll want this for: - **Service requests**: Let employees know their IT, HR, or facilities requests are done - **Approval workflows**: Tell requestors whether they got approved or rejected - **Order processing**: Send order confirmations when everything's shipped - **Document processing**: Deliver finished documents right to whoever submitted them - **Onboarding**: Confirm new employee setup is complete ### Prerequisites - Administrator or Standard user role to edit templates - Understanding of [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) - Basic knowledge of [automations](/products/pro/documenting/templates/automations/) ### Setting up requestor notification ### Alternative approaches #### Using multiple notification recipients Need to notify the requestor plus other people? Here's how: 1. Add multiple assignee picker fields ("Requestor" and "CC Recipients" work well) 2. Create separate notification tasks for each group 3. Set up automation rules to route each notification to the right people #### Conditional notifications based on outcomes Sometimes you need different messages for different results. Set it up like this: 1. Add a selection field for process outcome ("Approved", "Rejected", "Pending") 2. Create multiple notification tasks - one for each possible outcome 3. Use conditional visibility so only the right notification shows up #### Using webhooks for advanced notifications Got complex notification needs? Webhooks are your friend: 1. Set up a webhook on the final task completion 2. Connect it to middleware (Zapier, Make, Power Automate) and you can: - Send fancy HTML emails - Pull in attachments from other systems - Fire off SMS or Slack messages - Update external systems ### Best practices - **Clear labeling**: Name your assignee picker field something obvious - people shouldn't have to guess what it's for - **Test thoroughly**: Always run a test process before going live. Trust me on this one. - **Include context**: Pack your notifications with details using variables. Recipients hate vague emails. - **Set appropriate timing**: If your final data needs processing time, add a delay (30 minutes usually does it) - **Provide next steps**: Tell people what to do next - don't leave them hanging ### Troubleshooting **Notification not sending?** - Check if the assignee picker field actually has someone selected - Make sure your automation rule is switched on (easy to forget!) - Verify the task type is "Email - Auto Send" not just a regular task - For auto-send emails, the deadline needs to pass first - that's what triggers them **Wrong person getting notified?** - Double-check you picked the right field in your automation rule - Watch what users are actually selecting - they might be picking the wrong person - Pro tip: make the field read-only after someone picks their name **Missing data in the notification?** - Your variables might be pointing to the wrong fields - The fields you're referencing need to be filled out before the notification fires - Run a test with real data - that usually reveals the problem ### Example: IT service request completion Let me show you how this works with a real IT service request: 1. **Kick-off form** has three fields: - Assignee picker: "Select your name" - Request type dropdown - Description field 2. **Process steps** are simple: - IT reviews the request - IT does the work - IT uploads any documentation 3. **Final notification task** brings it all together: - Type: Email - Auto Send - Timing: 30 minutes after "Upload documentation" completes - Content includes all the request details plus attached docs - Automation assigns it to whoever started this whole thing Simple. Every service request closes the loop automatically - the person who asked for help knows exactly when it's done and gets everything they need. - **[Service level-based task assignment](https://tallyfy.com/products/pro/documenting/templates/automations/examples/service-level-assignment/)**: This automation system routes tasks to appropriate team members based on customer service levels or subscription tiers ensuring each customer receives expertise matching their package through conditional assignment rules and workload distribution strategies. Want to route [tasks](/products/pro/tracking-and-tasks/tasks/) to different team members based on customer service levels? Here's how Tallyfy automatically assigns the right expertise to match each customer's subscription tier - whether they're on your basic plan or your enterprise package. ## When do you need service-based routing? Think about these scenarios: - **Tiered customer support**: Your enterprise customers shouldn't wait in the same queue as free users. Different teams, different response times. - **Sales processes**: Million-dollar deals need your senior closers, not the new hire still learning the ropes - **Professional services**: Complex projects get senior consultants. Simple ones? Perfect for junior team members to build experience. - **Subscription management**: Free trial setups can be handled by anyone, but enterprise onboarding needs your A-team ## Setting up service-based assignment ### Basic service level routing Let's walk through a real example - routing tasks based on service packages. **Scenario**: You're onboarding new clients, and your Platinum customers deserve Sarah Chen (your best account manager). Not the intern. 1. **First, add a service selection field to your kick-off form[^1]**: - Field type: Dropdown or Radio Button - Options: "Basic", "Professional", "Platinum" - Label: "Select service package" 2. **Next, create assignment rules for each level**: **Rule 1: Platinum service assignment** ``` IF (Service Package field) is "Platinum" THEN Replace assignee(s) for "Prepare proposal" with "Sarah Chen" AND Replace assignee(s) for "Account setup" with "Sarah Chen" ``` **Rule 2: Professional service assignment** ``` IF (Service Package field) is "Professional" THEN Replace assignee(s) for "Prepare proposal" with "Mike Johnson" AND Replace assignee(s) for "Account setup" with "Mike Johnson" ``` **Rule 3: Basic service assignment** ``` IF (Service Package field) is "Basic" THEN Replace assignee(s) for "Prepare proposal" with "Support Team" group AND Replace assignee(s) for "Account setup" with "Support Team" group ``` ### Advanced patterns #### Workload-balanced assignment What if Sarah's swamped? Don't pile everything on one person - use groups instead: ``` IF (Service Package field) is "Platinum" THEN Replace assignee(s) for all account management tasks with "Senior Account Managers" group ``` Configure the group for round-robin assignment[^2]. Tallyfy spreads the work evenly. #### Multi-criteria assignment Sometimes service level isn't enough. You need more nuance: ``` IF (Service Package field) is "Enterprise" AND (Industry field) is "Healthcare" THEN Replace assignee(s) for "Compliance review" with "Healthcare Specialist Team" ``` Now you're matching expertise to both customer tier AND industry. Smart. #### Progressive expertise escalation Higher tiers often need more approvals (it's just how business works): ``` IF (Service Package field) is "Basic" THEN Hide "Executive review" step IF (Service Package field) is "Enterprise" THEN Show "Executive review" step AND Assign "Executive review" to "C-Suite" group ``` ## Real-world example: Technical support tiers Here's how one of our software clients handles 10,000+ support tickets monthly. They stopped drowning in chaos. **Kick-off form fields**: - Customer tier (dropdown): "Free", "Starter", "Growth", "Enterprise" - Issue type (dropdown): "Bug", "Feature Request", "Integration Help" **Their automation setup**: 1. **Free tier gets community support**: ``` IF (Customer Tier) is "Free" THEN Assign "Initial response" to "Community Managers" AND Set deadline to 48 hours ``` 2. **Starter tier gets standard support**: ``` IF (Customer Tier) is "Starter" THEN Assign "Initial response" to "Tier 1 Support" AND Set deadline to 24 hours ``` 3. **Growth tier gets priority support**: ``` IF (Customer Tier) is "Growth" THEN Assign "Initial response" to "Tier 2 Support" AND Set deadline to 4 hours ``` 4. **Enterprise gets dedicated support**: ``` IF (Customer Tier) is "Enterprise" THEN Assign "Initial response" to "Enterprise Success Team" AND Set deadline to 1 hour AND Show "Executive escalation" step ``` Each customer gets exactly what they're paying for. Your team stays sane. Win-win. ## Best practices - **Clear service definitions**: Your team needs to know what "Enterprise support" actually means - document it - **Backup assignments**: Sarah takes vacations. Have a fallback group ready (learned this the hard way) - **Consider time zones**: Enterprise customers in Sydney shouldn't wait for your California team to wake up - **Regular review**: Check assignment patterns monthly - you'll spot burnout before it happens - **Transparent routing**: Tell customers upfront how their package affects support speed. No surprises. [^1]: Form that collects data before launching a process run, enabling dynamic routing and pre-population [^2]: Tasks automatically distributed evenly among group members in sequential order, preventing workload imbalance - **[Synchronization](https://tallyfy.com/products/pro/documenting/templates/automations/examples/synchronization/)**: Tallyfy's synchronization automation uses the AND operator to ensure processes wait for multiple approvals or conditions to be met before proceeding with the next steps. ## Automation Example: Synchronization (Wait for Multiple Things) Ever needed your process to wait for several approvals before moving forward? That's synchronization - and Tallyfy makes it simple. ![BPMN diagram showing synchronization gateway waiting for both A and B to complete](https://screenshots.tallyfy.com/tallyfy/pro/bpmn-synchronization-gateway.png) *(This diagram shows waiting for both A AND B to finish before moving on)* Here's the secret: use the **AND** operator in Tallyfy [automations](/products/pro/documenting/templates/automations/). When you connect conditions with **AND**, *all* of them must be true before anything happens. It's like needing two keys to open a vault - you can't proceed with just one. ### Example: Wait for HR and Manager Approval Let's make this real. You're setting up an Employee Onboarding [process](/products/pro/tracking-and-tasks/processes/), and new hires can't start until both HR and their direct manager give the thumbs up. Sound familiar? First, create two [**Approve/Reject** tasks](/products/pro/tracking-and-tasks/tasks/what-types-of-tasks-can-i-create-with-tallyfy/#approvereject) - one assigned to HR, another to the manager. Simple. ![](https://screenshots.tallyfy.com/tallyfy/pro/desktop-light-hrmanager-approval-synchronization.png) Now here's where it gets interesting. Create a single [automation](/products/pro/documenting/templates/automations/) rule that checks if *both* tasks show "Approved" status: - **Rule:** ``` IF (HR Approval task) is "Approved" AND (Manager Approval task) is "Approved" THEN SHOW steps [List of next onboarding steps] ``` ![](https://screenshots.tallyfy.com/tallyfy/pro/desktop-light-hrmanager-automation-synchronization.png) See that **AND** between the conditions? That's your synchronization point. The onboarding steps stay hidden until both approvals come through. No more chasing people or wondering who approved what. ### Summary Want processes that wait for multiple green lights? The **AND** operator is your answer. It ensures nothing moves forward until every required condition is met. ### Variables - **[Insert variables](https://tallyfy.com/products/pro/documenting/templates/variables/how-can-i-use-insert-variables-in-tallyfy/)**: Variables in Tallyfy automatically transfer information between process steps by clicking the { } button to select data from earlier form fields creating personalized workflows that display exact information without retyping and update instantly when source data changes. ## 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](/products/pro/tracking-and-tasks/processes/). Here's what makes [variables](/products/pro/documenting/templates/variables/) powerful: they turn generic workflows into personalized ones. When someone fills out a [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) 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](/products/pro/documenting/templates/) open in edit mode - At least one [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) 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. :::tip[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[^1] - 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 ### Adding variables to step descriptions ### How variables work during process execution Here's what happens when your process runs: 1. Someone fills out a [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) 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](mdc:products/pro/integrations/document-management/file-request-links/) from your DMS) #### Renaming projects with field values Variables shine when combined with [auto-naming](/products/pro/tracking-and-tasks/processes/edit-processes/how-can-i-auto-name-a-process-in-tallyfy/). 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](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) 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." :::tip[Variables + Conditional Logic = Smart Templates] The real power comes from combining variables with [conditional automations](/products/pro/documenting/templates/automations/conditional-visibility-guide/). 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 :::caution[URLs with variables may contain hidden characters] When embedding variables in URLs within step descriptions, the editor may insert invisible UTF-8 BOM characters[^2] (%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. ::: [^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 ### Edit templates - **[Add a description to a template](https://tallyfy.com/products/pro/documenting/templates/edit-templates/add-description/)**: Adding descriptions in Tallyfy involves opening a template in Edit mode and clicking either Settings for template descriptions or directly on steps for step-specific descriptions where you can type your content and it saves automatically. ## How to add descriptions To add a description in Tallyfy, open your [template](/products/pro/documenting/templates/) in **Edit** mode and either click **Settings** for the overall template description or click directly on any step for step-specific descriptions. Type your description and it saves automatically. That's it. Need more details? Let's walk through each option. :::note[Changes only affect future processes] Remember, changes you make to a template in Tallyfy (like adding descriptions) only apply to *new* [processes](/products/pro/tracking-and-tasks/processes/) started *after* you make the change. They don't affect processes already running. ::: Here's exactly how to add descriptions: 1. Open the [template](/products/pro/documenting/templates/) in **Edit** mode. 2. Where you add the description depends on what you're describing: * **For the overall Template description**: Click the **Settings** (or **Config**) button in the top toolbar, head to the **Summary** tab, and you'll see the **Description** box waiting for you. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-click-config-template.png) ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-description-template.png) * **For a specific Step description (in Procedure templates)**: Just click directly on the [step](/products/pro/tracking-and-tasks/tasks/) you want to describe. The description box appears in the panel that opens - usually on the right side. * **For Document templates**: The main content area is your canvas. That's where your description or primary text goes. 3. Type your description into the text box. 4. Tallyfy saves changes automatically as you type - no save button needed. Simple. :::caution[Pasting content might lose formatting] If you copy text from other programs (like Word or Google Docs) and paste it into Tallyfy's description boxes or rich text editors, the original formatting (like fonts, colors, complex layouts) might not carry over perfectly. Tallyfy uses its own standard formatting to keep things consistent. ::: - **[Assign steps in the Tallyfy template builder](https://tallyfy.com/products/pro/documenting/templates/edit-templates/assign-steps-in-the-tallyfy-template-builder/)**: Tallyfy templates allow you to assign tasks to specific people groups job titles or guests with options for automation rules to dynamically change assignments based on process conditions. ## How to assign steps in Tallyfy templates Click the **Assign** tab for any step and pick who should handle it - specific members, groups, job titles[^2], or even guests. You can also leave steps unassigned or let automation rules handle the assignments dynamically. Here's the thing: assignments determine who gets each task when someone launches your process. Tallyfy gives you multiple ways to handle this - you can lock in specific people or keep things flexible with role-based assignments. Whatever works for your team. ### Prerequisites for assigning steps You'll need a few things before you can start assigning steps: - Administrator or Standard member role (Light members[^1] can't edit templates) - Access to the template you want to edit - [Groups created](/products/pro/documenting/groups/how-to-manage-groups-and-assign-tasks-in-tallyfy/) if you're planning group assignments - Guest email addresses ready for external assignments ## Step-by-step assignment process ## Assignment methods explained ### Assign to specific members Want the same person to handle a task every single time? This is your option. Once you set it, that's it - no need to pick someone during launch. **When to use**: Tasks with clear ownership like "HR Manager reviews application" or "Finance Director approves budget" **How to assign**: Just type and select the member's name from the dropdown. Done. ### Assign to groups Groups let multiple people share responsibility for a task. Any group member can jump in and complete it - perfect for spreading the workload while keeping everyone accountable. **When to use**: - Support tickets that any team member can handle - Document reviews where any QA person can take a look - Approvals where any manager can sign off **How to assign**: Type the group name and select it from the dropdown. Quick note: groups need to be [created in Settings](/products/pro/documenting/groups/how-to-manage-groups-and-assign-tasks-in-tallyfy/) first before they'll show up here. ### Assign by job title Job titles are like casting roles in a play - you define what role you need, but pick the specific person later. It's brilliant for flexible workflows. **When to use**: - Different people handle the same role depending on the project - You rotate responsibilities based on who's available - The same template works across departments with similar roles **How to assign**: 1. Pick **Job Title** from the assignment dropdown 2. Enter something descriptive like "Project Manager" or "Quality Reviewer" 3. When someone launches the process, they'll choose who fills that role **Real-world example**: Your client onboarding needs an "Account Manager" - but which one? Depends on the client, right? With job titles, whoever launches the process picks the right person for that specific client. Simple. ### Assign to guests Need someone outside your company to complete a task? That's what [guests](/products/pro/documenting/guests/) are for. They get an email with a secure link - no Tallyfy account needed. Easy for them, secure for you. **When to use**: - Getting client approvals or feedback - Collecting documents from vendors - Having contractors complete specific tasks **How to assign**: - Know the email already? Enter it directly - Not sure who yet? Leave it blank and let the process launcher decide - Quick tip: type `+guest@email.com` in any task comment for instant guest assignment ### Leave unassigned ("Nobody right now") Sometimes you don't want to lock in who does what. Fair enough. Leaving tasks unassigned gives you options. **What happens**: - "Assign launcher automatically" is ON? The person who launches the process gets it - "Assign launcher automatically" is OFF? Task sits there until someone claims it **When to use**: - Ad-hoc tasks where you'll figure out assignment based on workload - Tasks where anyone can volunteer - Processes where whoever starts it should handle the first few steps :::caution[Important: Group assignments with automatic launcher assignment] When a step is assigned to a group AND "Assign launcher automatically" is enabled, the process launcher will be added as an additional assignee alongside the group. This means both the group members AND the launcher can see and complete the task. To avoid this behavior, either: - Turn OFF "Assign launcher automatically" in the Advanced tab - Use specific member assignments instead of groups - Use automation rules to control assignments dynamically ::: ## Advanced assignment techniques ### Dynamic assignment with automation Here's where it gets interesting. [Automation rules](/products/pro/documenting/templates/automations/) let you change assignments on the fly based on what's happening in your process. **What you can do**: - Add assignees based on form answers (someone picks "High Priority"? Auto-assign your senior team) - Replace assignees when things change - Clear assignments completely to create unassigned tasks - Route tasks based on amounts, regions, priorities - whatever you need **Example**: Purchase request comes in. Over $10,000? Goes straight to the CFO. Under that? Department manager handles it. No manual routing needed. ### Multiple assignee requirements Need everyone to sign off on something? Here's how: 1. Assign multiple people or groups to the same step 2. Turn on "All assignees must complete this task" in Advanced settings 3. The task waits until everyone marks it done **Perfect for**: - Board approvals where everyone needs to vote - Multi-department sign-offs - Reviews that need multiple perspectives ### Assignment best practices **Be specific with job titles**: "Senior Marketing Manager" beats just "Manager" every time. Trust me - you'll avoid confusion when launching. **Think about workload**: Groups spread tasks naturally. Specific assignments? Great for accountability, but watch out for overloading your star performers. **Plan for vacations**: People take time off (shocking, I know). Groups and job titles give you built-in backup when someone's out. **Document your thinking**: Add a quick note in the step description about why you chose that assignment method. Future you will thank present you. **Test it out**: Launch a few test processes. See how assignments flow in real scenarios. Better to catch issues now than later. ## Troubleshooting assignment issues ### "I can't see a group in the assignment dropdown" Missing group? It needs to exist first. Head to **Settings** > **Groups** and create it there. (Note: only administrators can create groups.) ### "The wrong person got assigned" Let's check a few things: - Is "Assign launcher automatically" turned on? That might be overriding your setup - Got any automation rules running? They could be switching assignments - Using job titles? Remember, someone needs to pick the actual person during launch ### "Guests aren't receiving task notifications" Quick checklist: - Double-check that email address (typos happen) - Ask them to check spam folders - Make sure "Prevent guests from making or seeing comments" isn't blocking what they need to see ### "Multiple people need different parts of one task" Here's a thought: split it up. Create separate steps with their own assignments instead of cramming everything into one task. Works much better. ## Assignment impact on process flow Your assignment choices shape how work flows through your team: **Speed**: Specific assignments? Tasks start instantly. Groups? Might sit a bit while someone claims them. **Flexibility**: Job titles adapt to each situation but need input during launch. Worth it for the flexibility though. **Accountability**: Named assignments = clear ownership. Group assignments = shared responsibility. Both have their place. **Scalability**: Here's the thing - groups and job titles grow with your team. Specific assignments? You'll be updating them forever as people come and go. Bottom line: pick what works for your team's style. Mix and match different methods across your template. There's no one-size-fits-all approach here. [^1]: View-only permissions role with no task completion or template editing capabilities [^2]: Dynamic role-based routing feature allowing template flexibility without hardcoding assignees - **[Rename a template](https://tallyfy.com/products/pro/documenting/templates/edit-templates/change-name/)**: Tallyfy templates can be renamed in two quick ways: through the Settings menu by clicking the template name in the settings panel or directly clicking on the template name in Edit view and selecting the rename option with changes only affecting future processes started after the rename. ## Renaming a Tallyfy template You can rename a template in Tallyfy two ways - either through the Settings menu or by clicking directly on the template name. Both methods take less than 10 seconds. :::note[Changes only affect future processes] Changing a template's name in Tallyfy does **not** affect any processes that are already running from the old version of the template. The name change only applies to *new* processes started *after* you rename it. ::: Here's how to rename your [templates](/products/pro/documenting/templates/): **Method 1: Using the Settings/Config Menu** 1. Open the template in Tallyfy's Edit mode. 2. Click the **Settings** (or **Config**) button in the top toolbar. 3. Click on the current template name shown at the top of the settings panel. 4. Type the new name. 5. Click **Save**. Done. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-change-template-name.png) **Method 2: Directly from the Edit View** This one's even faster: 1. Open the template in Tallyfy's Edit mode. 2. Click directly on the template's name displayed at the very top of the editor screen. 3. Choose the **Rename** option. 4. Type the new name and save. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-rename-template-from-edit-view.png) - **[Change a template's status](https://tallyfy.com/products/pro/documenting/templates/edit-templates/change-template-state/)**: Tallyfy provides four template status options (Started In progress Finishing and Published) that can be changed by different user roles through either the main Templates section or the Template Editor settings to communicate whether a template is ready for use. ### Understanding template status Want to let your team know whether a [template](/products/pro/documenting/templates/) is ready to use? That's what template status is for - it shows if you're still building it or if it's good to go. Tallyfy gives you 4 status options: - **Started**: Just beginning to create the template. - **In progress**: Currently being worked on, maybe by several people. - **Finishing**: Almost done, perhaps under final review. - **Published**: Complete and ready for people to launch processes from it. :::note[Who can change the status?] Here's where it gets interesting - changing a template's status works differently than editing its content: - **Administrators**: Can change the status from anywhere (the main Templates list or within the Template Editor settings). - **Standard members**: Can always change the status from the main Templates list. They can *also* change it in the Template Editor settings *if* they have permission to edit that specific template. - **Light members**: Can't edit templates, but they *can* still change the status of a template from the main Templates list. (Yes, really!) ::: ### Changing template status You've got two ways to change a template's status: **Method 1: From the main Templates section** **Method 2: From the Template Editor (Admins/Standard members with edit rights only)** - **[Edit steps](https://tallyfy.com/products/pro/documenting/templates/edit-templates/edit-steps/)**: This content explains how to add and modify steps within Tallyfy templates including step descriptions assignments types form fields deadlines and advanced settings for workflow automation. ## Editing steps in templates You can add new steps and modify existing ones directly in Tallyfy [templates](/products/pro/documenting/templates/). :::note[Who can edit steps?] [Members](/products/pro/documenting/members/) with a "Light" role cannot edit templates or their steps. Only "Standard" members (if allowed by an Admin) or "Administrator" members can edit steps. ::: ### Adding new steps To add a step, open your template in Edit mode, scroll to the bottom of the steps list, click **Add Step**, type a name for your new step, and press Enter. That's it. ### Modifying existing steps To modify a step: - Navigate to the **Templates** library interface - Locate your target template and click the **Edit** icon (pencil symbol) ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-open-edit-mode-template.png) Once you're in edit mode, click any step to open its details panel on the right. You can edit everything about the step from here: #### Step description Write the instructions for the [task](/products/pro/tracking-and-tasks/tasks/). You can add text, formatting, images, files, links, tables, videos, [variables](/products/pro/documenting/templates/variables/), and [snippets](/products/pro/documenting/templates/snippets/). :::tip[Use videos for clear instructions] A short video (like a screen recording) can often explain a step better than lots of text. Consider embedding videos for complex tasks. ::: #### Assignment * **If you choose "Nobody right now"**: What happens when the process runs depends on the **Assign launcher automatically** setting (in the Advanced tab). If ON, the person starting the process gets assigned. If OFF, the task stays unassigned. * **Assigning Groups**: You need to [create the group first](/products/pro/documenting/groups/how-to-manage-groups-and-assign-tasks-in-tallyfy/) in Tallyfy before you can assign a task to it. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-assign-a-task-to-somebody.png) #### Step type Different step types behave differently (e.g., Approve/Reject steps have different buttons). See [Step Types Explained](/products/pro/tracking-and-tasks/tasks/what-types-of-tasks-can-i-create-with-tallyfy/) for details. :::tip[Prevent task debt with expiring tasks] Choose the "Expiring" type for FYI items or optional information sharing. These tasks auto-complete at deadline if not done manually, preventing [task debt](/products/pro/tutorials/how-to/how-to-avoid-task-debt/) from non-critical items piling up. Perfect for weekly updates, optional resources, or informational announcements. ::: :::tip[Email branding options] Email step types (Email Draft and Email Auto-Send) include a "Send Chromeless" option that removes Tallyfy branding from sent emails. Use this when emails should appear as standard messages rather than workflow notifications. See [Step Types](/products/pro/tracking-and-tasks/tasks/what-types-of-tasks-can-i-create-with-tallyfy/) for details. ::: #### Form fields See [Types of Form Fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) for more details. :::caution[Checklist field saving issue] If you encounter a "Capture ID field is required" error when saving a step with checklist fields, this typically happens when: - You've added checklist options but haven't saved the field configuration first - The checklist field validation rules are incomplete **To fix this error**: 1. Click on the checklist field to open its settings 2. Ensure all checklist items have been properly added 3. Set the validation rules (e.g., "at least one" or "all items") 4. Click outside the field settings to save the field configuration 5. The template should now save without errors If the error persists, try refreshing the page and re-entering the checklist field configuration. ::: #### Deadlines and timings :::note[Understanding start time vs deadline] **Start time** and **deadline** serve different purposes in task management: - **Start time**: When work should **begin** on the task. This helps with planning and scheduling but is not enforced. - **Deadline**: When work should be **complete** on the task. This is the due date that determines if a task becomes overdue. Both start times and deadlines can be set for tasks within processes (using the template editor) and for one-off tasks (when creating them directly). Example: A task might have a start time of "Monday 9 AM" (when you should begin working) and a deadline of "Wednesday 5 PM" (when it must be finished). ::: :::note[Understanding overall process deadlines] Your process's overall deadline depends on which task has the latest due date from launch. But here's the catch - if you set a deadline based on another step's completion (like "3 days after Step 2 finishes"), the timeline becomes flexible since you can't predict exactly when that other step will be done. ::: :::tip[Bulk deadline management] **Current limitation**: The template editor doesn't support bulk editing of deadlines across multiple steps simultaneously. Each step's deadline must be set individually. **Alternative solutions for managing many deadlines**: 1. **Power Builder Tool** - Advanced template creation tool with bulk deadline capabilities (contact support for access) 2. **Professional Services** - Tallyfy's team can assist with large-scale template setup using complimentary service hours 3. **Template duplication** - Create a master template with standard deadlines, then duplicate and adjust **When to use each approach**: - Power Builder: For complex templates with 20+ steps requiring varied deadlines - Professional Services: For migrating existing processes or implementing complex deadline patterns - Template duplication: When you have similar processes with minor deadline variations Contact support@tallyfy.com to discuss Power Builder access or professional services assistance. ::: #### Advanced settings - **Launch another process when this task is complete**: Set to "Yes" to automatically start another process (from a different template) when this task finishes. You can choose to add the new tasks into the current process or start a completely separate one. See [Launch another process guide](/products/pro/launching/launch-process-when-task-is-completed/). - **All assignees must complete this task**: If "Yes", the task isn't done until *everyone* assigned has marked it complete. - **Assign launcher automatically**: If a step has *no* assignees set, turning this ON means the person who starts the process will automatically be assigned. If OFF, it remains unassigned. - **Task is mandatory...**: If "Yes", this step cannot be removed when someone starts the process. - **Only assigned members can complete or edit...**: If "Yes", only people directly assigned can work on or complete the task (except Administrators, who can always access it). - **Emit webhook when completed**: If "Yes", Tallyfy sends an automatic notification to another web service (via a [webhook](/products/pro/integrations/webhooks/)) when this task is done. - **Prevent guests from making or seeing comments**: If "Yes", any [guests](/products/pro/documenting/guests/) assigned won't see or be able to add comments on this task. - **Unique Step Alias**: An internal ID for this specific step, mostly used for technical integrations via [webhooks](/products/pro/integrations/webhooks/) or the [API](/products/pro/integrations/open-api/). - **Tags**: Add organizational tags to this step. :::note[Outbound Webhooks & Incoming Webhooks] If you're looking to know more about [Webhooks](/products/pro/integrations/webhooks/) and integrating Tallyfy, check out the [**[INTEGRATIONS](/products/pro/integrations/)**](/products/pro/integrations/) section. You'll find multiple articles explaining in full detail how to integrate Tallyfy. ::: - **[Add guidance text to a step](https://tallyfy.com/products/pro/documenting/templates/edit-templates/how-to-add-guidance-text-to-template-steps/)**: Tallyfy allows users to add helpful guidance text directly below form fields in templates by accessing edit mode clicking on the desired step and entering instructions in the Advanced section of the Form Fields tab which then displays as italicized text with automatic clickable links when users work through the process. ## Adding guidance text to form fields Want to help users fill out forms correctly? Add guidance text directly below any [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) in Tallyfy - it shows up as helpful instructions right where people need them. This makes a huge difference when you're asking for specific formats or examples. Here's how to add guidance text to a form field: ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-add-guidance-text.png) When someone's working through the process, your guidance text shows up in italics right below the field label. Pretty handy. If you include any web links (URLs) in your guidance text, they'll automatically become clickable - perfect for pointing people to additional resources or examples. - **[Understanding assignment types](https://tallyfy.com/products/pro/documenting/templates/edit-templates/understanding-assignment-types/)**: Tallyfy templates allow you to assign tasks to specific people groups job titles or guests with options for automation rules to dynamically change assignments based on process conditions. ## Choosing assignment types for template steps You need to decide who does what in your Tallyfy [templates](/products/pro/documenting/templates/). There are several ways to assign [tasks](/products/pro/tracking-and-tasks/tasks/) - and your choice determines who gets work when someone [launches your process](/products/pro/launching/). ### Assigning to specific people or groups This works when you know exactly who should handle a task. Every time. #### Assigning to specific people - The same person gets this task each time the process runs - You won't need to choose assignees at launch (it's already decided) - Perfect for tasks with clear ownership - like approval from your CFO *How to:* Click the step > **Assign** tab > Type the member's name #### Assigning to groups Think of groups as pre-built teams. You'll want groups when: - Multiple people could handle the task - You'd rather not list everyone individually - Your team changes but the group stays constant (new hires automatically get included) *How to:* Click the step > **Assign** tab > Type the group name :::note[Setting up Groups] You need to [create groups](/products/pro/documenting/groups/how-to-manage-groups-and-assign-tasks-in-tallyfy/) in Tallyfy Settings before you can assign tasks to them. ::: ### Assigning based on job title Sometimes you know what role should handle a task - but not which specific person. That's where job titles come in. :::tip[Job Titles = Casting Roles in a Play] - **Fixed Assignment:** Like **choosing specific actors** for roles beforehand. The same actors always play those parts. - **Job Title Assignment:** Like saying you need a **"Lead Actor"** but not picking who yet. When the play starts (process launches), you **hold auditions** and choose who plays the Lead Actor *for that specific show*. Different actors can play the role on different nights. This is useful when the person doing the task depends on the project or client, but the *job function* is always the same (e.g., always needs a "Project Manager"). ::: Here's how it works: - You define the role in your template ("Legal Reviewer", "Project Manager", etc.) - When someone [launches the process](/products/pro/launching/), they pick who fills that role this time - Next run? They can choose someone else. The flexibility is built in. *How to:* Click the step > **Assign** tab > Choose **Job Title** > Enter a clear role name ### Assigning to guests Need someone outside your company to complete a [task](/products/pro/tracking-and-tasks/tasks/)? That's what guest assignments are for - clients, vendors, contractors who don't have Tallyfy accounts. *How to:* Click the step > **Assign** tab > Choose **Guest** > Add their email (or leave blank to decide later) What happens at launch: - Got an email in the template? The [guest](/products/pro/documenting/guests/) is assigned automatically - Left it blank? You'll enter the email when launching - Either way, they receive an email with a direct link - no login needed :::note[Guest Email Shortcut] You can quickly assign a guest by typing `+guest@email.com` in any task comment box. ::: ### Using automation rules for assignments Want assignments that adapt? [Automation rules](/products/pro/documenting/templates/automations/) let you change who gets a [task](/products/pro/tracking-and-tasks/tasks/) based on what happens during the process. If someone selects "Budget over $10K" in a form field, you can automatically route approval to senior management. Your rules can: - Add extra assignees - Switch out the current assignee - Remove everyone and start fresh Check out [Automate task assignments](/products/pro/documenting/templates/automations/actions/asignment-actions/) for the complete guide. ### Members - **[Convert a member to a guest](https://tallyfy.com/products/pro/documenting/members/convert-member-to-guest/)**: Converting a member to a guest in Tallyfy requires first deactivating their account and then changing their status to guest which takes about 2 minutes and frees up a paid member seat while restricting their access to only assigned tasks through email links. ## How to change a member into a guest To convert a member to a guest in Tallyfy, you'll deactivate their account first, then change their status to guest. This two-step process takes about 2 minutes. ### What you need - Administrator permissions - The person must currently be an active [member](/products/pro/documenting/members/) in your Tallyfy organization ### Step 1: Deactivate the Member account You can't convert an active member directly - you need to deactivate their account first. Here's how: ### Step 2: Change the deactivated account to Guest Almost done. Now let's convert them to a guest: That's it. ### What happens after conversion The change takes effect immediately. Here's what changes for that user: - Their account switches from [member](/products/pro/documenting/members/) to [guest](/products/pro/documenting/guests/) status - They lose dashboard access - no more logging into Tallyfy directly - They can *only* work on [tasks](/products/pro/tracking-and-tasks/tasks/) through special [guest links](/products/pro/documenting/guests/how-to-find-a-guest-task-link-in-tallyfy/) sent by email - You free up a paid member seat (great for keeping costs down) - **[Change the role of a member](https://tallyfy.com/products/pro/documenting/members/how-can-i-change-a-members-role-in-tallyfy/)**: Administrators can change member roles in Tallyfy by navigating to Settings > Organization > Members clicking the member's name and selecting a new role from the dropdown with changes taking effect immediately. ## How to change a member's role To change a member's role in Tallyfy, go to **Settings** > **Organization** > **Members**, click their name, and select the new role from the dropdown. That's it. You'll need Administrator permissions to make this change - Standard and Light members can't modify roles. ### What you need - Administrator permission level - At least one other [member](/products/pro/documenting/members/) whose role you want to change ### Available Member roles Tallyfy uses three [member roles](/products/pro/documenting/members/) to control what people can do: - **Administrator**: Full control over everything in Tallyfy - templates, processes, settings, the works - **Standard**: Can work with processes and templates based on permissions you set - **Light**: Perfect for occasional users who just need to complete assigned [tasks](/products/pro/tracking-and-tasks/tasks/) Simple. ### Steps to change a member's role The change takes effect immediately. The member will see their new permissions the next time they log in. ### When you might change roles Here's when role changes make sense: - Someone's getting promoted? Give them Administrator access if they'll be managing the whole Tallyfy setup - Have a contractor who only works on specific [tasks](/products/pro/tracking-and-tasks/tasks/) occasionally? Switch them to Light - it's more cost-effective - Team member switching departments? Update their role to match their new responsibilities Remember: you can change roles anytime. If someone needs temporary elevated access, you can always switch them back later. ### Removing members from your organization **Need to remove a member completely?** While you can't directly delete members, you can deactivate them: 1. Go to **Settings** > **Organization** > **Members** 2. Click on the member's name 3. Toggle their status to **Inactive** 4. Click **Save** Deactivated members: - Can't log in to Tallyfy - Don't count toward your member limit - Keep their historical data (for audit trails) - Can be reactivated anytime if needed This approach frees up space for new team members while preserving process history. - **[How to remove a member](https://tallyfy.com/products/pro/documenting/members/how-can-i-remove-a-member-from-my-tallyfy-organization/)**: Administrators can deactivate member accounts in Tallyfy by navigating to Settings > Organization > Members and selecting Deactivate Account which removes access immediately and allows reassignment of their current tasks to other active members. ## Removing members from your organization To remove a member from Tallyfy, navigate to **Settings** > **Organization** > **Members**, click their name, and select **Deactivate Account** at the bottom of their profile. The member loses access immediately, and you'll decide what happens to their current tasks. ### What you need - Administrator permission level - The name of the [member](/products/pro/documenting/members/) you want to remove ### Removing a member Here's how to permanently deactivate someone's account: 1. Go to **Settings** > **Organization** > **Members**. 2. Click on the name of the member you want to remove. 3. Scroll down to the bottom of their profile page. 4. Click **Deactivate Account**. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-remove-member.png) That's it. The deactivation happens instantly. ### Choosing what happens to their tasks When you deactivate a [member](/products/pro/documenting/members/), you'll need to decide what happens to their current [tasks](/products/pro/tracking-and-tasks/tasks/). You've got two options: 1. **Reassign their tasks** (recommended): - Pick other active members to take over the work - Choose specific tasks or reassign everything from certain [templates](/products/pro/documenting/templates/) ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-conflict-resolution-example.png) 2. **Leave tasks unassigned**: - Select **Deactivate without reassigning their tasks** - Tasks become unassigned - you'll need to reassign them manually later - This works well if you want to redistribute tasks individually ### What happens after removing a member Once you click that deactivate button, here's what happens: - Their account gets deactivated instantly - They lose access to your Tallyfy organization immediately - Their paid seat[^1] becomes available for new team members - Tallyfy logs who performed the deactivation and when (you can check this in the member's Activity section) :::warning[Important: Check Public Kick-off Forms First!] **Wait - before you deactivate anyone, check if they created or are listed as the inviter for any templates used in public kick-off forms[^2]. You'll want to update those forms first.** Here's why: Deactivating a [member](/products/pro/documenting/members/) can sometimes break public [kick-off forms](/products/pro/launching/triggers/kick-off-forms/) if that member was connected to them. Let me explain what happens: - **Scenario 1: Member was the *inviter* for a form (but didn't create the template)** - Tallyfy automatically switches the inviter to whoever created the template - Public sharing stays ON - no action needed from you - **Scenario 2: Member was the *creator* of the template used for a public form** - Tallyfy automatically turns OFF public sharing for that form - The public link stops working (yes, immediately) - To fix this, an Administrator needs to turn public sharing back ON and choose a new member to associate with the form ::: ### Checking deactivation history Need to find out who deactivated a member? Here's how: 1. Go to **Settings** > **Organization** > **Members** 2. Find the deactivated member's name (you might need to filter the list) 3. Check the **Activity** section at the bottom of their profile page The activity log shows exactly who performed the deactivation and when it happened. [^1]: Tallyfy bills per active member monthly or yearly. Deactivated members don't count toward billing. [^2]: External submission forms that don't require login. Links can break if the form creator is deactivated. - **[Manage member permissions](https://tallyfy.com/products/pro/documenting/members/how-do-i-manage-member-permissions-in-tallyfy/)**: Administrators can control what Standard members can do in Tallyfy by managing five key permission areas including template editing viewing starting processes accessing running processes and inviting new members through template-specific Config settings or process-specific Settings panels. ## How to control what team members can do To manage member permissions in Tallyfy, go to any template's **Config** settings or a running process's **Settings** panel, then adjust the permission checkboxes for each Standard member. That's it. ### What you need - Administrator [role](/products/pro/documenting/members/) - Standard [members](/products/pro/documenting/members/) whose permissions you want to manage ### Understanding the types of permissions Here's the thing - as an Administrator, you're in charge of exactly what Standard members can and can't do. Five key areas need your attention: 1. **Editing Templates**: Should this person be able to change specific process [templates](/products/pro/documenting/templates/)? (Think carefully - one wrong edit can mess up everyone's workflow) 2. **Viewing Templates**: Can they see specific templates in the library? 3. **[Starting Processes](/products/pro/launching/)**: Are they trained enough to launch new [processes](/products/pro/tracking-and-tasks/processes/) from specific templates? 4. **Accessing Processes**: Can they find and view processes that are already running? 5. **[Inviting Members](/products/pro/documenting/members/how-to-invite-and-activate-members-on-tallyfy/)**: Do you trust them to [invite](/products/pro/documenting/members/how-to-invite-and-activate-members-on-tallyfy/) new people to your Tallyfy organization? ### Setting permissions for a specific Template Want to control who can edit, view, or launch a template? Here's how. :::note[Hiding templates from users] Here's something that trips people up: if you want to completely hide a template from Standard or Light users[^1], you can't just remove one permission. You need to restrict **ALL THREE** - EDIT, READ, and LAUNCH. Leave even one box checked? That template stays visible in their library. Sneaky, right? ::: ### Setting permissions for a specific running Process Now let's talk about processes that are already running. You might need to hide sensitive processes from certain team members - here's how to do that. ### Tips for managing permissions After helping hundreds of companies set up their permissions, here's what works: - **Template editing is powerful** - and dangerous. One accidental change to a [template](/products/pro/documenting/templates/) affects every future process launched from it. Only give this permission to people who really understand your workflows. - **Process visibility matters**. If someone needs to collaborate on running [processes](/products/pro/tracking-and-tasks/processes/), they need view access. Don't be too restrictive here - it creates bottlenecks. - **[Process launching](/products/pro/launching/) requires training**. I've seen chaos when untrained folks start launching complex workflows. Make sure people understand the process before giving them launch permissions. - **People change roles**. Set a quarterly reminder to review permissions - especially after promotions, role changes, or department transfers. Takes 10 minutes. Saves headaches. - **Think in groups, not individuals**. Got a sales team? Marketing department? Create standard permission sets[^2] for each group. Much easier than managing person by person. [^1]: Light users have view-only permissions and cannot complete tasks or edit templates [^2]: Permission templates you can apply to multiple users at once, avoiding individual configuration - **[Resend or withdraw invites](https://tallyfy.com/products/pro/documenting/members/how-to-resend-or-withdraw-invites-in-tallyfy/)**: Administrators can manage pending member invitations by accessing Organization Members settings to either resend invitations when emails are lost or expired or withdraw them when wrong addresses were used or plans changed. ## Managing pending member invitations Need to resend or cancel a member invitation? You can manage all pending invites directly from your Organization Members settings - whether someone's email got lost in spam or you simply invited the wrong address. ### What you need - Administrator permission level - At least one invitation showing as "Pending" in your member list ### When to resend an invitation You'll want to resend when: - The person says they never got your email (happens more than you'd think) - Their invitation expired - yes, these links have time limits - They deleted the email by accident - You suspect it's sitting in their spam folder ### When to withdraw (cancel) an invitation Time to withdraw? Here's when: - Oops - you typed the wrong email address - Plans changed and they're not joining after all - You need to reinvite them with different permissions - You need that paid [member](/products/pro/documenting/members/) seat for someone else right now ### How to resend or withdraw an invitation Simple as that. ### What to expect after each action **After resending:** - They'll get a brand new invitation email with a fresh link - The acceptance deadline resets - they get the full time again - Don't worry - this doesn't use up another [member](/products/pro/documenting/members/) seat **After withdrawing:** - That invitation link? Dead instantly. - The [member](/products/pro/documenting/members/) seat opens up - you can invite someone else right away - The invitation vanishes from your pending list (no trace left) - **[Invite and activate members](https://tallyfy.com/products/pro/documenting/members/how-to-invite-and-activate-members-on-tallyfy/)**: Administrators can invite team members to Tallyfy by clicking the Invite+ button and entering their email address while managing invitations through Organization Members settings where they can resend or withdraw pending invites and verify successful activation through member status updates. ## Inviting team members and managing their activation To invite someone to Tallyfy, click the **Invite+** button anywhere you see it and enter their email address - they'll get an invitation email to set up their account. Simple as that. ### What you'll need first - Administrator permissions (only admins can send invites) - An available paid [member](/products/pro/documenting/members/) seat in your plan - The email addresses of people you're inviting ### Inviting new members to your team ### Managing your sent invitations Need to check on pending invites? Head to **Settings** > **Organization** > **Members** and look for anyone with "Invited" status - that's everyone who hasn't joined yet. What if someone didn't get the email? No problem. You can resend it right from that same page. Invited the wrong person? Click **Withdraw** to cancel the invitation. :::tip[Troubleshooting invitation delivery issues] **Invitations not arriving?** Common solutions: 1. **Check spam/junk folders** - Have them search for emails from tallyfy.com 2. **Verify email address** - Even small typos prevent delivery 3. **Whitelist Tallyfy** - Add tallyfy.com to allowed senders in email settings 4. **Corporate firewalls** - IT may need to allow emails from noreply@tallyfy.com 5. **Resend after 24 hours** - Sometimes email servers have temporary issues 6. **Check invitation status** - Settings > Organization > Members shows if invite is pending Still not working? Contact support with the exact email address for investigation. ::: ### The activation process Once you send the invite, here's what your new team member needs to do: That's it - they're in! ### Verifying someone joined successfully Want to make sure your invite worked? Here's how to check: - **[Light members](https://tallyfy.com/products/pro/documenting/members/light-members/)**: Light members in Tallyfy are task-focused users who can complete assigned work and participate in processes but cannot create or edit templates and are available for organizations with SSO configured starting October 2024. ## Understanding Light member capabilities Light members work with focused task completion in Tallyfy - they can't create or edit templates, but they excel at getting assigned work done. Light members are designed for task-focused team members who don't need full platform capabilities. :::note[Light user availability] **Introduced**: October 2024 **Eligibility requirements**: - Organizations with Single Sign-On (SSO) configured - Organizations meeting specific configuration requirements - Can be manually enabled by support for specific cases **Why these requirements?** Light users solve the SSO problem where company email addresses can't be added as guests. The role provides a middle ground between guests and full members. ::: ### What Light members can do Light members keep it simple. They focus on task execution without the overhead of template management. #### Core capabilities Here's what Light members bring to the table: - **Task Work:** - Complete assigned [tasks](/products/pro/tracking-and-tasks/tasks/) in running processes - View task details, instructions, and attached files - Add comments to tasks they're working on - Upload files when completing tasks - Mark tasks as complete or incomplete - **Process Participation:** - Access [processes](/products/pro/tracking-and-tasks/processes/) where they have assigned tasks - View the overall process flow (but only for processes they're part of) - See their upcoming tasks in the dashboard - Track their task completion history - **Basic Access:** - Log into Tallyfy with their own credentials - Update their profile information - View [guests](/products/pro/documenting/guests/) they're collaborating with on tasks - Access the mobile app for on-the-go task completion :::note[Template visibility for Light members] Light members only see templates in their library when an Administrator grants them LAUNCH permission. Even then, they can't edit or create templates - just launch processes from them (if that permission is specifically granted). **Knowledge-only mode**: Light members are perfect for [knowledge-only mode](/products/pro/tutorials/knowledge-only-mode/) - they can view procedures and reference materials without tracking execution. Grant them view access to templates used as documentation, and they can search and reference SOPs without launching formal processes. ::: :::tip[Light members vs Guests] Don't confuse Light members with [Guests](/products/pro/documenting/guests/). Light members are users within your organization with their own login credentials. Guests are external email addresses (like customers or vendors) who only access specific tasks via email links. ::: ### What Light members cannot do The restrictions are clear and intentional. Light members can't: - **Template Management:** - Create new [templates](/products/pro/documenting/templates/) - Edit existing templates (even with permissions) - Organize templates into folders - Import or export templates - Delete archived templates - **Process Control:** - Launch new processes (unless specifically given LAUNCH permission) - Change process settings or permissions - Reassign tasks to other members - Delete running processes (soft delete or permanent) - Create pre-runs or manage automated actions - **Administrative Functions:** - Invite new members or guests - View all organization members - Access account management information - Change organization settings - View API keys or integrations - Manage permissions for other users - **Process Management:** - Archive or unarchive processes (button appears but doesn't function) - Bulk operations on processes - Export process data directly ### Launching processes as a Light member Here's something that surprises many people: Light members CAN launch processes, but only when specifically allowed. By default, Light members cannot launch any processes. But here's the key - Administrators can grant LAUNCH permission for specific templates to Light members. When they do, those Light members can start new processes from those templates. #### How to enable process launching for Light members Administrators follow these steps: 1. Navigate to the template's **Config** settings 2. Find the Light member who needs launch access 3. Grant them the **LAUNCH** permission for that specific template 4. The template now appears in the Light member's library with a launch button #### Smart use cases for Light member launching This selective launching capability opens up powerful workflows: - **Daily checklists** - Let warehouse staff start their morning safety inspection process - **Customer intake** - Allow receptionists to launch new client onboarding workflows - **Incident reporting** - Enable field workers to initiate safety incident processes - **Quality checks** - Let production line workers start quality control processes The beauty? Light members can start these pre-approved processes without ever seeing or editing the template design. They just launch and go. :::tip[Pro tip for process launching] Create template folders specifically for Light member processes. Name them clearly like "Daily Operations - Light Users" or "Field Team Processes". This helps Light members quickly find the processes they're allowed to launch while keeping other templates out of sight. ::: ### When Light members make sense Light members shine in specific scenarios. Here's where they fit perfectly: **Field and frontline workers:** - Delivery drivers checking off route stops - Technicians completing service checklists - Construction crews following safety procedures - Healthcare workers documenting patient rounds **External collaborators:** - Contractors working on specific projects - Vendors completing quality checks - Partners handling designated tasks - Temporary staff during busy seasons **Task-focused internal roles:** - Data entry specialists processing forms - Warehouse staff managing inventory counts - Customer service reps following call scripts - Reception desk handling visitor check-ins **Knowledge base users:** - Teams who need to reference [knowledge-only procedures](/products/pro/tutorials/knowledge-only-mode/) - Staff accessing SOPs and how-to guides without tracking - Employees viewing reference materials and documentation - Workers who read procedures but don't need formal task completion ### Optimization strategies with Light members Smart organizations use Light members strategically. Consider this approach: 1. **Audit your current Full members** - Look for people who only complete tasks, never creating or editing templates 2. **Convert task-only users** - Switch them to Light member status for better role alignment 3. **Set clear role boundaries** - Reserve Full member licenses for process designers and managers 4. **Monitor usage patterns** - Track who actually creates templates versus who just executes tasks :::tip[Role optimization example] A 100-person company with 20 process designers and 80 field workers? Keep 20 Full member licenses for the designers. Convert those 80 field workers to Light members. This aligns roles with actual needs while maintaining full functionality. ::: ### Upgrading from Light to Full member Need to give a Light member more capabilities? [Changing roles](/products/pro/documenting/members/how-can-i-change-a-members-role-in-tallyfy/) takes seconds: 1. Navigate to **Settings** > **Organization** > **Members** 2. Find the Light member you want to upgrade 3. Click their role dropdown and select **Standard** or **Administrator** 4. Changes take effect immediately - no logout required The member keeps all their task history and active assignments. They just gain new capabilities based on their new role. ### Light member best practices Make Light members successful with these tips: **Clear task instructions** - Since Light members can't edit templates, make sure task descriptions are crystal clear. Include step-by-step guidance, examples, and expected outcomes. **Mobile-first thinking** - Many Light members work from mobile devices. Design your tasks with mobile screens in mind - shorter descriptions, simpler forms, fewer required fields. **Permission planning** - If Light members need to launch specific processes, grant LAUNCH permission only for those templates. Keep their interface clean and focused. **Training simplicity** - Light members need minimal training. Show them how to log in, find assigned tasks, and mark them complete. That's it. The limited interface means less confusion. - **[Standard and admin members](https://tallyfy.com/products/pro/documenting/members/standard-admin-members/)**: Administrators have complete control over Tallyfy accounts while Standard members have limited permissions focused on daily work tasks and template management based on admin-granted access levels. ## Comparing Administrator and Standard member roles Tallyfy gives you two main paid [member roles](/products/pro/documenting/members/) - Administrator and Standard. Each role comes with different access levels and capabilities. (There's also a Light role, which we'll touch on below). ### Quick cost comparison: Full vs Light members Here's the deal: **Full members** (that's Administrator and Standard roles) can create templates and execute tasks. **Light members**? They're limited to completing assigned tasks - no creating or editing templates for them. :::tip[Save on member costs] Light members cost significantly less than Full members. Smart move? Give Light member licenses to folks who just need to complete tasks (think warehouse staff, field workers, external contractors). Save those Full member licenses for your process designers and managers who actually create workflows. Visit our [pricing page](https://tallyfy.com/pricing/) for current rates. ::: ### Administrator role Administrators get the keys to the kingdom. They control everything in your company's Tallyfy account. #### What Administrators can do Let's break down their powers: - **Account Settings:** - Change [billing](/products/pro/settings/billing/) info and subscription plans - Update [organization details](/products/pro/settings/org-settings/how-can-i-update-my-organization-details/) - Configure custom SMTP settings for organization emails - Manage organization logo and custom branding - Configure SAML/SSO settings[^1] (with support assistance) - View and manage all [templates](/products/pro/documenting/templates/) and [processes](/products/pro/tracking-and-tasks/processes/) - **People Management:** - [Invite new members](/products/pro/documenting/members/how-to-invite-and-activate-members-on-tallyfy/) to join your team - Set permissions for Standard members (deciding what they can and can't do) - Edit member profiles - Remove members when needed - Check activity history - see who's been doing what - **Process Control:** - Create, edit, and view all process [templates](/products/pro/documenting/templates/) - Control who gets access to specific templates and running [processes](/products/pro/tracking-and-tasks/processes/) - Permanently delete templates and processes (not just archive them) - Pin important templates for organization-wide visibility - Manage every aspect of running processes #### How to find Administrators Want to know who the Administrators are? Simple. 1. Navigate to **Settings** > **Organization** > **Members** 2. Look for anyone with the **Administrator** role label ### Standard role Standard members work with more limited permissions. They're focused on getting daily work done in Tallyfy - not managing the entire account. #### What Standard members can do (if allowed by an Admin) Here's where it gets interesting. Standard members can do quite a bit, but only if an Administrator gives them permission: - **Working with Templates:** - Create, edit, and view [templates](/products/pro/documenting/templates/) they've been given access to - Launch processes from templates (but only when they have LAUNCH permission) - Organize templates into folders for better structure - Import templates from other sources :::note[Template visibility and permissions] Here's something that trips people up: Templates show up in the "Templates" library for Standard and Light members unless **ALL THREE** permissions (EDIT, READ, and LAUNCH) are removed. Want to hide a template completely? Administrators need to remove all three permissions. **Heads up**: New templates don't automatically give Standard members any permissions. Administrators have to explicitly grant permissions (EDIT, READ, and/or LAUNCH) before Standard members can touch them. ::: - **Working with Others:** - [Invite](/products/pro/documenting/members/how-to-invite-and-activate-members-on-tallyfy/) other Standard members (if the Admin allows this) - View the member and [guest](/products/pro/documenting/guests/) list for your organization - Access shared tags and text [snippets](/products/pro/documenting/templates/snippets/) - Check out [task](/products/pro/tracking-and-tasks/tasks/) assignments and email history of colleagues - **Other Access:** - View your organization's [API](/products/pro/integrations/open-api/) key (handy for integrations) - Create and manage groups (if Administrator enables this feature) #### What Standard members cannot do There are clear boundaries. Standard members can't: - Control access permissions for templates or running [processes](/products/pro/tracking-and-tasks/processes/) - Permanently delete templates or processes (they can only archive/soft delete[^2]) - Pin templates for organization-wide visibility - Access member profiles or organization settings - Configure SMTP, SAML, or custom branding - Touch billing info or subscription plans - that's Admin territory ### When to use each member type Choosing the right role matters. Here's who gets what: **Administrator role fits**: - Company executives who need complete system control - IT administrators setting up integrations and managing security - Operations managers who oversee all workflows across departments - HR leaders responsible for user access and permissions **Standard (Full member) role works for**: - Department heads who create and manage team workflows - Process improvement specialists designing new templates - Team leads launching processes and tracking progress - Quality assurance staff who update and refine procedures **Light member role is perfect for**: - Field service technicians working through checklists - Warehouse staff processing daily shipments - Customer service reps following call scripts - External contractors handling specific tasks - Part-time employees with focused responsibilities :::note[Light member limitations] Light members see templates only when an Administrator grants LAUNCH permission. Can't create, edit, or organize templates at all. But here's why that's actually great - this focused access makes Light members ideal for pure task execution roles, and they come at a substantial discount compared to Full members. ::: [^1]: Security Assertion Markup Language for enterprise single sign-on authentication [^2]: Data remains in database but hidden from UI; can be restored unlike permanent deletion ### Pricing - **[Non-profit discount](https://tallyfy.com/products/pro/pricing/how-to-apply-for-tallyfys-nonprofit-program-discount/)**: Tallyfy offers permanent discounts for qualifying nonprofit organizations with official charitable status recognition excluding political religious educational governmental healthcare and private foundation entities through an application process requiring account creation and submission of organizational documentation and mission details for Tallyfy's eligibility review. ## What is Tallyfy's nonprofit organization discount? Tallyfy provides a permanent discount for qualifying nonprofit and charitable organizations committed to social impact initiatives. Contact Tallyfy for current discount rates. ## What are the nonprofit eligibility criteria? Qualifying organizations require official charitable status recognition from governmental tax authorities (such as IRS 501(c)(3) designation in the United States or equivalent international certifications). Several organizational categories remain **ineligible** for this nonprofit program: * Political advocacy and legislative influence organizations. * Faith-based institutions and religious congregations. * Educational institutions including academic establishments. * Government agencies. * Public opinion research and influence organizations. * Healthcare facilities and medical insurance providers. * Private foundations. Organizations practicing discrimination or mandating specific religious affiliations for service access remain ineligible for program consideration. Eligibility determination rests with Tallyfy evaluation processes. Organizations uncertain about qualification status should consult support teams before application submission. ## What is the application process for the nonprofit discount? Organizations meeting nonprofit eligibility requirements should follow these application procedures: Tallyfy conducts thorough application reviews. Upon approval, organizations receive the nonprofit discount applied to their subscription. ## What are the discount terms and conditions? * Discount eligibility requirements are determined by Tallyfy. * The discount applies permanently to annual subscriptions. * Retroactive discount application remains unavailable. * Tallyfy maintains exclusive eligibility determination authority and reserves rights to approve, deny applications, or modify program criteria. According to [nonprofit technology research](https://www.gartner.com/reviews/market/business-process-management-platforms), organizations increasingly seek workflow platforms to maximize operational efficiency. - **[Sales tax](https://tallyfy.com/products/pro/pricing/sales-tax/)**: Tallyfy subscriptions are not subject to sales tax because the company is based in Missouri where SaaS is not taxable and they currently do not meet economic nexus thresholds in other states or international VAT registration requirements though they monitor these thresholds and will notify customers in advance if tax collection becomes legally required. ## Understanding sales tax for Tallyfy subscriptions **You won't see sales tax added to your Tallyfy subscription.** We're based entirely in Missouri, where Software as a Service (SaaS) isn't subject to sales tax. Since we don't meet specific economic nexus criteria at present, we don't currently collect sales tax anywhere. Simple as that. But let's dig into why - and what this means for you. ### Why Missouri doesn't tax SaaS Missouri taxes tangible personal property and certain enumerated services. Remotely-accessed software? Not on that list. The Missouri Department of Revenue treats SaaS differently from downloadable software. When you use Tallyfy, you're accessing our servers remotely. You're not downloading anything. No physical transfer happens. That distinction matters legally - it keeps SaaS in the non-taxable category. Recent letter rulings from Missouri's tax authority confirm this position. They've consistently held that subscription-based, remote-access digital services aren't taxable as sales of tangible personal property or telecommunications services. ### What about other states? Here's where it gets interesting. As a Missouri company, we only need to charge sales tax in other states if we hit certain thresholds - what's called "economic nexus." Each state sets its own economic nexus thresholds - typically based on sales volume or transaction counts. Check your state tax authority for current thresholds, as these change frequently. Once a company crosses these thresholds, they must register with that state and start collecting sales tax - but only if that state actually taxes SaaS. Currently, about 25 US jurisdictions tax SaaS in some form. States like New York, Texas, and Washington tax it fully. Others like California and Florida don't tax it at all. Some states, like Iowa, tax it for consumers but exempt business use. For Tallyfy specifically: We monitor our sales by state. If we cross the threshold in a state that taxes SaaS, we'll register there and update our billing system accordingly. We'll notify affected customers well in advance. ### B2B vs B2C - does it matter? In the US, most states that tax SaaS apply the same rules to both B2B and B2C transactions. A few states provide business-use exemptions, but you'd typically need to provide exemption certificates. Since Tallyfy primarily serves business customers, you might qualify for these exemptions in certain states - though again, we're not currently collecting tax anywhere. ### International sales and VAT International tax works differently: **European Union (EU)**: - B2C sales: Subject to VAT at the customer's country rate - B2B sales: Usually "reverse charged" when customers provide a valid VAT ID (meaning you handle the tax, not us) - We'd use the Non-Union OSS scheme to simplify compliance if we start collecting **United Kingdom (UK)**: - B2C digital services: Subject to 20% UK VAT from the first sale - B2B sales: Generally reverse charged with valid VAT registration **Other countries**: Each has its own rules. Canada has GST/HST, Australia has GST, and so on. Currently, we're not registered for VAT in any country. If this changes, we'll provide advance notice and help you understand any impacts. ### State-by-state economic nexus thresholds Economic nexus thresholds vary significantly by state and change frequently. Some states have no sales tax at all (like Delaware, Montana, New Hampshire, and Oregon), while others set different dollar amounts and transaction counts as their triggers. ### What this means for you **For US customers**: - No sales tax on your Tallyfy subscription currently - If this changes, we'll notify you at least 30 days in advance - You remain responsible for any use tax obligations in your state (consult your tax advisor) **For international customers**: - No VAT/GST currently charged - B2B customers may have reverse charge obligations - Check with your local tax authority about your responsibilities ### Future changes Tax laws evolve constantly. States are expanding their definitions of taxable services. International agreements are harmonizing digital taxation. We track these changes closely. Our approach: 1. Monitor our sales thresholds quarterly 2. Track legislative changes in sales tax laws 3. Register proactively when we approach thresholds 4. Communicate changes to affected customers early 5. Help you understand any impacts ### Our current understanding **Important disclaimer**: This page reflects our current understanding of applicable tax laws. Tax laws are complex and change frequently. This information shouldn't be considered tax advice. We base our tax positions on: - Current Missouri Department of Revenue guidance - State tax authority rulings and statutes - Consultation with tax professionals - Industry best practices We could be wrong. Laws might have changed since we wrote this. Your specific situation might be different. ### Questions about sales tax? Tax situations vary by business, location, and use case. If you have questions about: - Your specific tax obligations - Exemption certificates - International tax requirements - Changes to our tax collection **Please contact us.** Email [support@tallyfy.com](mailto:support@tallyfy.com) or use the chat feature in your account. We're happy to discuss your specific situation, provide invoices in your required format, or connect you with appropriate tax resources. While we can't provide tax advice, we can explain our policies and help you get the information you need for your own tax compliance. ### Key takeaways - Tallyfy doesn't currently charge sales tax anywhere - Missouri (our home state) doesn't tax SaaS - We'll collect tax only when legally required - You'll get advance notice of any changes - International VAT/GST isn't currently collected - This reflects our current understanding - Contact us with any questions Remember: Every business has unique tax obligations. Consult your tax professional about your specific situation. We're here to help with the Tallyfy side of things whenever you need us. ### Settings - **[Billing](https://tallyfy.com/products/pro/settings/billing/)**: Tallyfy uses Recurly billing partner with an innovative credit system that provides administrators comprehensive subscription management including payment methods invoice history credit management and flexible billing options with special pricing programs like Fair Price Guarantee discounts for eligible countries. ## Billing overview The **Billing** section in Settings lets administrators manage subscriptions, payment methods, account limits, and billing. Tallyfy uses Recurly as our billing partner with a credit system for flexible payment management. ### Subscription management The **Billing** section includes: * **Plan Overview**: Current subscription plan and usage metrics * **Payment Management**: Update payment cards and billing addresses * **Invoice History**: Past invoices and payment records * **Credit Management**: Monitor and manage billing credits See [How to access and manage billing details](/products/pro/settings/billing/how-to-access-and-manage-my-billing-details/) for more information. ### Credit system Tallyfy's billing credits work as a pre-paid balance: * Credits are used before your payment card is charged * You only pay for *active* members (billing begins when they accept their invite or sign in) * Removing a member or downgrading mid-cycle returns pro-rated credits for unused time * Credits expire after 5 years and are non-refundable * You can purchase credits via bank transfer (contact support for details) :::note[Payment card required] You must keep a valid payment card on file even if you have credits. This ensures service continues if credits run out. ::: ### Billing notifications By default, you receive billing emails instantly when changes occur (like adding a new member). * **Daily Billing Option**: Contact support to switch to daily billing notifications - one summary email instead of instant updates. ### What happens if my payment fails? If Tallyfy cannot process your payment: 1. **Immediate notification**: Billing emails alert you with instructions to update your payment method. 2. **Grace period (Days 1-7)**: Your account continues functioning normally. Update your card in **Settings > Billing > Edit Payment Card**. 3. **Read-only mode (Days 7-14)**: You can still log in and view/export all data, but cannot create or launch processes. 4. **Suspension (Days 14-30)**: Access suspended. Contact [support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/) to resolve. 5. **Data deletion (After 30 days)**: Tallyfy reserves the right to delete your data with notice. :::warning[Act quickly on payment failures] Update your payment information immediately to avoid service disruption. ::: ### After account deletion - **90-day backup retention**: Recovery may be possible during this period - **Permanent deletion**: After 90 days, all data is irreversibly removed ### Account and member limits Your plan includes limits for: * Maximum Full members * Maximum Light members * File storage space See [Tallyfy's account and member limits](/products/pro/settings/billing/what-are-tallyfys-account-and-member-limits/) for details. ### Special pricing programs #### Coupon codes To use a discount coupon: #### Fair Price Guarantee Tallyfy offers discounts for organizations in eligible countries. Eligibility requirements: * Most of your users must be located in an eligible country * You must be subscribed to an annual plan To apply for the Fair Price Guarantee: :::note[Payment method] Your payment method must be from a bank in the eligible country to qualify for the Fair Price Guarantee discount. ::: *See also: [Non-profit Discount Program](/products/pro/pricing/how-to-apply-for-tallyfys-nonprofit-program-discount/)* - **[Organization settings](https://tallyfy.com/products/pro/settings/org-settings/)**: Tallyfy administrators can configure organization-wide settings that control member permissions billing branding integrations and other company-wide administrative options affecting all team members across the entire system. ## Managing organization-wide settings Tallyfy organization settings control how the platform works for your entire company. These settings affect all team members and determine company-wide policies and configurations. Only **Administrator** users can access and modify these settings. From here, you manage core infrastructure like member permissions, billing, company branding, integrations, and administrative policies that shape how your team uses Tallyfy. - **[Personal settings](https://tallyfy.com/products/pro/settings/personal-settings/)**: Personal Tallyfy settings allow you to customize your individual user experience including profile details password management notification preferences language selection and other account configurations that only affect your personal workflow. ## Managing personal Tallyfy settings This section covers individual Tallyfy account settings that only affect your personal user experience and preferences. Personal settings let you customize profile details, password management, notification preferences, language selection, and other individual account configurations. These options help you optimize your personal Tallyfy workflow experience to match your work style. ### Billing - **[Manage billing](https://tallyfy.com/products/pro/settings/billing/how-to-access-and-manage-my-billing-details/)**: Administrators can access and manage Tallyfy billing details by navigating to Settings > Billing where they can view current plans payment methods credits billing history and update payment cards while also being able to change billing contacts through support modify subscription plans apply discount codes and cancel subscriptions using either the self-service form or emergency email support process. ## Accessing and managing billing details This guide demonstrates how administrators can access, view, and manage Tallyfy billing details through the subscription interface. Effective billing management ensures accurate subscription oversight, payment method maintenance, and financial record keeping. To find your billing information: ### Viewing history and updating payment method From the main **Billing** screen: * Click **View Billing History** to see past invoices and a plan summary. * Click **Edit Payment Card** to update your saved credit or debit card details. :::note[Keep a payment card on file] You need a valid payment card saved even if you have pre-paid credits. This ensures your service continues without interruption if credits run out. ::: ### Changing the Billing Contact The Tallyfy user who initially created the organization's account is set as the primary billing contact by default. To change the primary billing contact or to add additional email addresses to receive billing communications: ### Changing your plan To change your subscription plan (e.g., upgrade or change billing frequency): ### Understanding the credit system The billing section shows your current credit balance. Tallyfy uses a credit system where credits are applied before your card is charged. See the [main Billing overview](/products/pro/settings/billing/) for a full explanation of how credits work. ### Changing how often you get billing notifications By default, billing emails (like invoices, payment confirmations, and subscription updates) are sent instantly when changes occur. To get fewer emails: ### Using discount coupon codes If you have a valid discount code: :::note[Applying for the Fair Price Guarantee discount] To get the Fair Price Guarantee discount, you must first apply through the [Fair Price Guarantee page](https://tallyfy.com/pricing/fair-price-guarantee/) and receive an approved coupon code from Tallyfy. ::: ### Canceling your subscription To cancel your Tallyfy subscription, use the self-service cancellation form when possible. The standard cancellation process ensures proper account closure and final billing. :::tip[Emergency cancellation process] **If you cannot access the standard cancellation form** due to technical issues or location restrictions: 1. **Email support directly** - Send your cancellation request to support@tallyfy.com from your registered account email 2. **Include account details** - Provide your organization name, billing email, and reason for cancellation 3. **Request confirmation** - Ask for written confirmation of cancellation and final billing status 4. **Response time** - Support typically processes urgent cancellations within 24 hours **Important**: Cancellation takes effect at the end of your current billing period. You'll retain access until then. ::: ### What happens if I miss a payment? 1. Immediate notification via email 2. After 7 days: read-only mode (view and export only) 3. After 14 days: access suspended 4. After 30 days: Tallyfy reserves the right to delete data Update payment info in **Settings > Billing > Edit Payment Card** or [contact support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/). ### Data retention after cancellation or deletion - **30-day export window** after termination - **90-day backup retention** after deletion (recovery may be possible) - **Permanent deletion** after 90 days from all systems - **[Account and member limits](https://tallyfy.com/products/pro/settings/billing/what-are-tallyfys-account-and-member-limits/)**: Tallyfy offers Full Members who can create and edit templates and Light Members who can only complete assigned tasks with trial accounts limited to 10 members and 10 guests and 100 task assignments and 10 simultaneous processes while guests are unlimited external collaborators outside your organization. ## Account and member limits ### Member roles Tallyfy offers two distinct [member roles](/products/pro/documenting/members/) with differentiated capabilities: * **Full Members**: Can access all platform features, including creating and editing [templates](/products/pro/documenting/templates/). This category includes Admin and Standard roles. * **Light Members**: Can only complete assigned [tasks](/products/pro/tracking-and-tasks/tasks/) and participate in launched processes. They **cannot** create or edit templates. An optional Data Feed add-on for [Tallyfy Analytics](/products/pro/integrations/analytics/) is also available. ### Member role capabilities | Feature | Light Member | Full Member | | --------------------------- | ------------ | ----------- | | Create/Edit Templates | No | Yes | | Launch/Assign Processes | Yes | Yes | | Complete/Track Tasks | Yes | Yes | | Get Reminders | Yes | Yes | | Watch Templates/Processes | Yes | Yes | ### Trial plan limits During the free trial period, Tallyfy trial accounts have these specific limits: * Maximum 10 [members](/products/pro/documenting/members/) allowed per account * Maximum 10 [guests](/products/pro/documenting/guests/) permitted per account * Maximum 100 total [task assignments](/products/pro/tracking-and-tasks/tasks/) across all processes * Maximum 10 processes running simultaneously ([processes](/products/pro/tracking-and-tasks/processes/)) If these limits impact your trial evaluation, or if you require more than the standard 14-day trial period, please [contact Tallyfy support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/) to discuss a possible extension. ### Members vs. guests * **Members**: People within your organization using Tallyfy (e.g., employees, contractors). Members are assigned roles based on their needs (Full or Light). * **Guests**: People outside your organization (e.g., clients, vendors, partners) who only complete specific [tasks](/products/pro/tracking-and-tasks/tasks/). Guest access is **unlimited**. :::note[External domains for partners and consultants] If you work with external partners or consultants who need access to your Tallyfy account, you can add their company's email domain (e.g., `consultingfirm.com`) to an exclusion list in your Account settings. This configuration marks users with that email domain as external collaborators. See [Become a Tallyfy Partner](/products/pro/miscellaneous/how-can-i-become-a-tallyfy-partner/) for details. ::: For complete platform details, visit our [platform options page](/products/pro/pricing/). ### Org settings - **[Organization branding](https://tallyfy.com/products/pro/settings/org-settings/how-can-i-personalize-my-tallyfy-branding-and-emails/)**: Tallyfy administrators can fully customize the platform with company logos brand colors guest interfaces and advanced CSS styling while custom SMTP configuration enables branded email communications though complete white-labeling isn't available due to technical security and operational constraints. ## Customizing Tallyfy with your organization's branding Administrators can customize Tallyfy to match your company branding. This personalization creates a professional, cohesive experience that aligns with your organization's visual identity and brand standards. ### Customizable branding elements * **Logo customization**: Display your company logo prominently in Tallyfy task views and email communications. * **Brand colors**: Apply your corporate color palette throughout the member interface and email templates. * **Guest experience**: Provide a professional, branded interface for external guests and collaborators. * **Advanced styling**: Add custom CSS code to modify standard visual elements (like headings or tables) across your entire Tallyfy platform. ### Changing logo and colors :::tip[Logo upload requirements and troubleshooting] **File format**: JPG format works most reliably. PNG files sometimes cause issues. **Recommended size**: 200x50 pixels (or similar aspect ratio) **File size**: Keep under 2MB for best performance **Troubleshooting**: If your logo shows as a spinning circle or won't upload: - Convert PNG to JPG format - Resize to recommended dimensions - Clear browser cache and try again - Try a different browser if issues persist ::: ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-customizing-branding.png) ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-see-brandingcolors-tasks.png) ### Customizing content style with global CSS :::note[Advanced feature] This requires knowledge of CSS programming. ::: You can add custom CSS rules to modify how standard visual elements (like headings, lists, or tables) appear in task descriptions, [templates](/products/pro/documenting/templates/), and [documents](/products/pro/documenting/documents/) throughout your Tallyfy account. For example, you could make all H2 headings display in a specific brand color or adjust the default table styling to match your corporate design standards. To add custom CSS styling: ```css ul, ol { list-style-position: outside; padding-left: 1rem !important; } ul { list-style-type: none; } ul li { vertical-align: middle; } ul li::before { content: "▪"; color: #f26523; display: inline-block; align-items: center; width: 1rem; margin-left: -1rem; font-size: 22px; vertical-align: middle; } table { margin-left: 0 !important; width: 100% !important; } table tbody tr td { padding: 8px 12px; } table > thead tr td, table > tbody:first-child tr:first-child td { background: #f26523; } table > thead tr td, table > thead tr td *, table > tbody:first-child tr:first-child td, table > tbody:first-child tr:first-child td * { color: white !important; } table > tbody:first-child tr:nth-child(odd):not(:first-child) td, table > tbody:not(:first-child) tr:nth-child(odd) td { background-color: white; } table tbody tr:nth-child(even) td { background-color: #f2f2f2; } h1, h1 * { font-sidebar: order: 400 !important; } h1, h2, h3 { margin-top: 1rem !important; margin-bottom: 1rem !important; } froala-bp-view .process-timeline { display: inline; } ``` ### Why complete white-labeling isn't available While Tallyfy provides extensive branding customization options, complete white-labeling (hiding all references to Tallyfy) isn't technically or operationally feasible. We've maximized customization within realistic constraints. Here's why full white-labeling doesn't work: #### Technical limitations * **Security compliance constraints**: Our [HSTS compliance](/products/pro/compliance/hsts-compliance/) and [BIMI compliance](/products/pro/compliance/bimi-compliance/) are specifically tied to the `tallyfy.com` domain. These critical security protocols cannot function on custom domains. * **JavaScript library restrictions**: Several essential JavaScript libraries and security components can only execute properly on the `tallyfy.com` domain for security and licensing reasons. * **Clickjacking protection**: We implement security controls that prevent logins and signups outside our domain, protecting users from phishing attacks. #### Operational realities * **Documentation access**: This user manual you're reading is hosted on `tallyfy.com`. Your users will inevitably need access to help documentation, revealing Tallyfy as the underlying platform. * **Support interactions**: Unless you field 100% of customer support requests internally, users will contact [Tallyfy support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/) when they need help - immediately revealing the true vendor. * **Compliance transparency**: When clients request SOC 2 Type 2 compliance documentation (as they should), our certifications are assigned to Tallyfy, Inc. You cannot hide Tallyfy's existence anywhere in the security and compliance lifecycle. * **Billing transparency**: While [official Tallyfy partners](/products/pro/miscellaneous/how-can-i-become-a-tallyfy-partner/) can use the "unbilled domains" feature to exclude their own consulting domain from client billing, the invoicing and billing interface still clearly shows "Tallyfy" as the service provider. #### What Tallyfy does offer We've taken branding customization to its maximum practical extent: * **Visual branding**: Add your logo, colors, and custom CSS throughout the platform * **Email customization**: Configure [custom SMTP](/products/pro/integrations/email/how-to-set-up-custom-smtp-in-tallyfy/) to send emails through your own email server * **Partner programs**: Our [Ambassador program](https://tallyfy.com/partners/) provides additional branding options for qualified partners The reality is that attempting to "pretend" a white-labeled SaaS product is made by another entity is neither sustainable nor honest. Tallyfy will be revealed as the vendor at some point in the customer relationship - whether through support interactions, compliance requests, or technical requirements. ### Setting up custom email sending (SMTP) You can configure Tallyfy to send all emails via your company's dedicated email server instead of Tallyfy's default email service. This configuration provides superior brand consistency and enhanced organizational control over email communications. Learn more: [Customize email sending](/products/pro/integrations/email/how-to-set-up-custom-smtp-in-tallyfy/). - **[Remove a member](https://tallyfy.com/products/pro/settings/org-settings/how-can-i-remove-a-member-from-my-tallyfy-organization/)**: Administrators can remove members from their Tallyfy organization by first deactivating them through Settings > Organization > Members and then permanently deleting them while reassigning any pending tasks to other active members. ## Removing a member from your organization This guide explains how administrators can safely remove a [member](/products/pro/documenting/members/) from your Tallyfy organization while managing their existing responsibilities. ### Important deletion constraints Before attempting to remove a member, understand these system requirements: #### Two-step deletion process Tallyfy requires members to be **disabled first** before permanent deletion. This safety mechanism prevents accidental data loss and ensures proper task reassignment. #### Administrator protection rules - **Default Administrator**: The member designated as default administrator cannot be removed until you transfer this role to another administrator. Navigate to **Organization Settings** and assign a different member as default administrator first. - **Last Administrator**: You cannot remove the last administrator in your organization. Promote another member to administrator role before attempting removal. - **Protected Accounts**: System accounts like "Tallyfy Bot" cannot be removed as they handle automated processes. #### Common deletion blockers If you're unable to remove a member, check: 1. **Is the member already disabled?** Check their status in the Members list 2. **Is this the default administrator?** Look for the "Default Admin" badge 3. **Is this your only administrator?** Verify you have another active admin 4. **Are there pending task reassignments?** Complete all reassignment dialogs For detailed solutions, see our [troubleshooting guide](/products/pro/settings/org-settings/troubleshooting-member-deletion/). ### Task reassignment during removal When you deactivate a member, Tallyfy automatically helps reassign their pending [tasks](/products/pro/tracking-and-tasks/tasks/) and any [template steps](/products/pro/documenting/templates/) currently assigned to them. This critical process prevents work from being lost or forgotten. Tallyfy will prompt you to select another active member to take over these responsibilities: ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-conflict-resolution-example.png) After you successfully reassign all items, you'll receive a confirmation message that the member has been completely removed from your organization. ### Checking who removed a member You can determine who deactivated a specific member by viewing the deactivated member's profile (locate them in the **Members** list, possibly using available filters) and checking the **Activity** section located near the bottom of their profile. - **[Update organization details](https://tallyfy.com/products/pro/settings/org-settings/how-can-i-update-my-organization-details/)**: Tallyfy administrators can update organization details like company names and contact information by navigating to Settings then Org Details under My Organization where they can modify and save the necessary changes. ## Updating organization details Tallyfy administrators can update essential organizational information including company names, contact details, and other foundational settings. Keeping organizational details current ensures accurate system branding, proper communication routing, and maintained professional presentation across all Tallyfy interactions. :::note[Organization name limitations] **Can't change your organization name?** During initial setup, the organization name field may be locked. This is by design to prevent accidental changes during configuration. To change your organization name after initial creation, contact [Tallyfy support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/) for assistance. ::: - **[Customize work week](https://tallyfy.com/products/pro/settings/org-settings/how-to-adjust-task-deadlines-to-work-week/)**: Tallyfy administrators can configure organization-wide working days and hours in the settings to ensure task deadlines automatically adjust to fall within actual business operations rather than on weekends or outside designated work hours. ## Adjusting task deadlines to match your work week Tallyfy administrators can configure organization-wide working days and hours to ensure realistic task scheduling aligned with actual business operations. Tallyfy uses these configurations to automatically adjust task [deadlines](/products/pro/tracking-and-tasks/tasks/), preventing deadline assignments during non-working periods including weekends or outside designated business hours. This scheduling ensures feasible deadline expectations across all organizational workflows. ### Configuring working days and hours :::note[How deadlines adjust] If a calculated deadline falls on a non-working day (based on your settings) or outside your set working hours, Tallyfy **always pushes the deadline forward** to the *start of the next working period*. It never moves deadlines backward. Example: A deadline calculated for Saturday moves to Monday morning (assuming Monday is set as a workday). ::: ### Benefits of setting working days and hours * **Realistic deadlines**: Helps ensure tasks aren't due when people aren't typically working. * **Better planning**: Helps schedule workflows based on actual work time. * **Consistency**: Uses the same work schedule rules across your organization. These settings are set once by an Administrator and apply to the entire organization. ### Currently unsupported deadline features Tallyfy uses calendar days for all deadline calculations. While you can configure which days of the week are work days, Tallyfy does not currently support: - **Country-specific holidays** (e.g., Labor Day in the US, Boxing Day in the UK) - **Organization-specific holidays** (e.g., company closure days, annual shutdown periods) - **Person-specific unavailability** (e.g., individual vacation days, sick leave, personal time off) All deadline calculations use the simple work week pattern you configure, without accounting for these exceptions. :::tip[Public holiday data coming soon] Tallyfy maintains a comprehensive dataset of national holidays for over 200 countries and territories at [tallyfy.com/national-holidays](https://tallyfy.com/national-holidays/). This free API provides accurate public holiday data for business day calculations. In a future release, we plan to integrate this public holiday data directly into deadline calculations. This will allow working day and working hour deadlines to automatically skip national holidays in your country, giving you even more accurate scheduling. ::: :::note[Need these features now?] If your organization needs support for organization-specific holidays, vacation tracking, or more complex deadline calculations today, please [contact our support team](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/). Your feedback helps us prioritize features for our development roadmap. ::: - **[Auto-launch templates](https://tallyfy.com/products/pro/settings/org-settings/how-to-auto-launch-templates-for-new-members/)**: Tallyfy automatically launches designated onboarding templates for new members when they join your organization providing structured training and immediate task assignments to streamline adoption and reduce administrative overhead. ## Automating new member onboarding Tallyfy enables organizations to automatically launch specific [templates](/products/pro/documenting/templates/) for [new members](/products/pro/documenting/members/) when they join your organization. This feature provides new members with a structured, consistent onboarding experience. ### Prerequisites Before setting up this feature, ensure you have: - Administrator access to your Tallyfy organization - An existing [template](/products/pro/documenting/templates/) specifically designed for new member onboarding - The template must be available to all members (not restricted to certain roles or specific members in its settings) ### Setting up auto-launch templates ### How auto-launch works Once configured, when a new member accepts their invitation and activates their account: 1. The chosen [template](/products/pro/documenting/templates/) automatically launches as a [process](/products/pro/tracking-and-tasks/processes/) specifically assigned to that new member 2. They receive immediate email notifications about their first [assigned tasks](/products/pro/tracking-and-tasks/tasks/) 3. The process appears prominently in their [Tasks view](/products/pro/tracking-and-tasks/tasks-view/), providing clear guidance through the onboarding steps 4. The process follows all standard tracking and completion rules established in your organization ### Benefits for adoption and training Using this feature provides several benefits: - **Structured onboarding**: Ensures every new member receives exactly the same initial process experience - **Self-guided training**: Allows new members to complete training tasks at their own optimal pace - **Reduced administrative work**: Eliminates the need to manually launch onboarding processes for each new member - **Increased platform adoption**: Gets members actively using the platform immediately upon joining - **Standardized knowledge transfer**: Provides identical key information to all new members consistently, avoiding the [forgetting curve problem](/products/pro/tutorials/why-documentation-training-fails-forgetting-curve/) of traditional training - **Measurable completion tracking**: Easily monitor and track onboarding progress across all new members ### Template design recommendations Consider including these elements in your auto-launch template: - Welcome message and company information - Platform tutorial steps (with links to relevant help articles) - Introductions to key team members and stakeholders - Required training materials or [compliance](/products/pro/compliance/) documents - A final step to collect valuable feedback about the onboarding experience ### Additional considerations - The template launches immediately when the new member activates their account - You can only configure one template to auto-launch for new members at a time - The name of the launched process will follow your organization's default process naming conventions - Administrators can monitor completion progress using the [Tracker view](/products/pro/tracking-and-tasks/tracker-view/) This feature integrates seamlessly with other tools like [welcome snippets](/products/pro/documenting/templates/snippets/) to create a complete onboarding experience. - **[Customize your organization](https://tallyfy.com/products/pro/settings/org-settings/organization-customization-settings/)**: Organization settings in Tallyfy allow administrators to customize member permissions domain configurations content creation task management onboarding schedules notifications and webhooks to control how the platform operates across the entire organization. ## Customizing organization settings Settings found under **Settings > Organization > Customization** control how Tallyfy operates for everyone in your organization. :::note[Admin only] Only users with the Administrator role can access and change these settings. ::: ### Member permissions * **Allow non-Admins to invite members?**: If **Yes**, Standard members can also invite other members (limited to Standard or Light roles only). If **No**, only Administrators have invitation privileges. * **Enable non-Admins to create/manage groups?**: If **Yes**, Standard members can create and manage [groups](/products/pro/documenting/groups/). If **No**, only Administrators can manage group operations. ### Organization domains (Managed under **Settings > Organization > Domains**) #### Domain configuration Under **Settings > Organization > Domains**, you configure your company's email domains (e.g., `yourcompany.com`). These domains: * **Distinguish Members vs. Guests**: Tallyfy uses this list to automatically identify internal members (email matches a listed domain) compared to external guests. * **Enable Auto Join functionality**: If **ON**, anyone signing up for Tallyfy with an email matching your listed domains will automatically join *your* organization. This is typically recommended to prevent employees from accidentally creating separate accounts. #### Adding domains To add or manage your organization's email domains: 1. Navigate to **Settings > Organization > Domains** in your Tallyfy application. 2. Follow the detailed on-screen instructions to add, edit, or remove domains from your organization's list. ### Content creation * **Enable HTML authoring?**: If **Yes**, users can edit HTML code directly in text editors (for advanced formatting capabilities). If **No**, they use the standard visual editor interface. * **Set new templates viewable by creator/Admin only?**: If **Yes**, newly created [templates](/products/pro/documenting/templates/) are initially visible only to the creator and Administrators until explicitly shared with other users. ### Task management * **Auto-complete overdue tasks?**: If **Yes**, Tallyfy automatically marks [tasks](/products/pro/tracking-and-tasks/tasks/) complete if they exceed their deadline by a specified amount of time (e.g., 2 months). * **Auto-archive completed processes?**: If **Yes**, Tallyfy automatically archives [processes](/products/pro/tracking-and-tasks/processes/) a specified number of weeks after all their tasks are completed. * **Default deadline for tasks**: Configure a default deadline (e.g., 3 days) that applies to new tasks or template steps when no specific deadline is chosen. ### Onboarding settings * **Launch template for new members**: Select a specific [template](/products/pro/documenting/templates/) to automatically launch for every new [member](/products/pro/documenting/members/) joining your organization. See [Auto-launch templates guide](/products/pro/settings/org-settings/how-to-auto-launch-templates-for-new-members/). ### Working hours and schedules * **Default work week**: Select your organization's standard work days (e.g., Mon-Fri). * **Default working hours**: Configure the start and end times for your standard workday. Deadlines automatically adjust based on these hours. See [Customize work week guide](/products/pro/settings/org-settings/how-to-adjust-task-deadlines-to-work-week/). ### Notification settings * **Default email digest days (Members/Guests)**: Configure the default days that *new* members and guests receive summary emails. Individual users can modify their personal settings later if needed. ### Webhook date formatting * **Format of webhook date field values**: Select the date format for data sent via [webhooks](/products/pro/integrations/webhooks/). ### Saving changes Click **Save Changes** at the bottom of the page after adjusting settings. - **[Member deletion](https://tallyfy.com/products/pro/settings/org-settings/troubleshooting-member-deletion/)**: This comprehensive guide addresses common issues and solutions when removing organization members from Tallyfy including error message troubleshooting and system behavior details for administrators managing member deactivation and deletion processes. ## Common issues and solutions for removing organization members Can't delete a member from your Tallyfy organization? The system requires specific conditions to be met before member removal. Here's how to resolve common blockers and handle edge cases. ### Quick diagnosis Run through this checklist to identify your issue: 1. **Check member status** - Active, Disabled, or Invited? 2. **Check admin role** - Default Admin or Administrator badge? 3. **Count administrators** - How many total admins in your organization? 4. **Note exact error** - What message appears when attempting deletion? ### Common error messages #### "Please disable the user before deletion" Tallyfy uses a two-step deletion process for safety: 1. Navigate to **Settings** > **Organization** > **Members** 2. Click the member's name 3. Click **Deactivate Member** 4. Complete task reassignment 5. Then use the permanent deletion option #### "Cannot modify the default administrator" Transfer the default admin role first: 1. Click on a different administrator's profile 2. Select **Make Default Administrator** 3. Return to original member 4. Proceed with deactivation If no other admins exist, promote a Standard member to Administrator first. #### "Bot users cannot be disabled" Bot accounts (like Tallyfy Bot) cannot be removed. They: - Don't count toward billing - Post automated comments - Handle system tasks #### "Cannot disable the last administrator" Create another administrator first: 1. Select any Standard member 2. Click **Change Role** → **Administrator** 3. Then remove the original admin ### Special scenarios #### Member shows as removed but still has access 1. Clear browser cache and cookies 2. Verify member status shows "Deactivated" 3. Check for active API tokens - revoke manually 4. If access persists after 30 minutes, contact support #### Can't find deactivated member Deactivated members are hidden by default: 1. Go to **Members** list 2. Use filter: **Show: All** or **Show: Deactivated** 3. Search by name or email #### Bulk member removal For multiple deletions via API: - Process in batches of 10 - Allow 5 seconds between deletions - Always disable before deleting - Use the two-step process for each ### System behavior details #### Email and name changes When deleted, the system: - Appends "(Deleted)" to last name - Changes email to `{email}.deleted.{user_id}` - Example: `john.doe@company.com` → `john.doe@company.com.deleted.12345` This allows re-inviting the same person later without conflicts. #### What happens to member data **Immediately removed**: - Login capability - API access tokens - Active sessions - Password data **Preserved for compliance**: - Task completion history (name shows with "(Deleted)") - Process participation records - Comments and attachments - Audit trail entries #### Task reassignment When no suitable member exists for reassignment: - Tasks default to "Tallyfy Bot" (system user) - Common in: last member deletion, bulk deletions, API deletions without reassignment ### API deletion **Required sequence**: ``` 1. DELETE /organizations/{org_id}/users/{user_id}/disable 2. Wait for 200 response 3. DELETE /organizations/{org_id}/users/{user_id}/delete ``` **With reassignment**: ``` DELETE /organizations/{org_id}/users/{user_id}?with_reassignment=true&to={new_user_id} ``` **Rate limits**: Maximum 10 deletions per minute, 429 error if exceeded ### Complex edge cases #### Organization with single member - Cannot delete last member - Contact support for organization closure #### Circular dependencies Admin A backs up Admin B, Admin B backs up Admin A: - Add third admin temporarily to break cycle #### Template with 1000+ processes - May timeout during deletion - Use batch reassignment via API - Process in groups of 100 ### Recovery options **Accidental deletion**: Contact support immediately with: - Organization name - Member email - Deletion date Support may restore recent deletions. For older deletions, send new invitation. ### When to contact support Contact support when: - Errors don't match those listed - Deletion affects 50+ processes - Server errors (500-series) appear - Deletion pending over 1 hour **Provide**: Organization name, member email, exact error, screenshot ### Prevention tips - Maintain at least 2 administrators - Document default administrator - Test deletion in sandbox first - Use consistent offboarding procedures - **[Member statuses](https://tallyfy.com/products/pro/settings/org-settings/understanding-member-statuses/)**: Tallyfy has four member status types - Active for normal users who can log in and count toward limits, Invited for pending invitations that don't count until accepted, Deactivated for removed members who can't access anything, and Bot/Unbilled for special integration or partner accounts that don't count toward your member total. ## Member status types in Tallyfy In **Settings > Organization > Members**, you'll see different statuses next to each person's name. These indicate their access level and account status within your Tallyfy organization. ### Status types overview | Status | What it Means | Account Status | |--------------------|----------------------------------------------------------------|----------------------------| | **Active** | A normal user who can log in and use Tallyfy (based on role). | Counts toward account limits | | **Invited** | You sent them an invitation, but they haven't accepted yet. | Does not count until active | | **Deactivated** | You removed them; they cannot log in or use Tallyfy anymore. | Does not count | | **Bot / Unbilled** | Special account (e.g., for integrations or partners) that doesn't count towards your account. | Does not count | ### Active status "Active" means the [member](/products/pro/documenting/members/) has joined and can use Tallyfy based on their assigned role (Admin, Standard, or Light). Active members count towards your account limits and have full access to platform features based on their role permissions. ### Invited status "Invited" means you've sent an invitation, but the person hasn't clicked the email link and set up their password yet. They cannot use Tallyfy, and they don't count toward your account during this pending state. Once they accept the invitation, their status automatically changes to **Active**, and they count toward your account limits. ### Deactivated status "Deactivated" means an Administrator has removed the member from the organization. They can no longer log in or access any Tallyfy features. When you deactivate someone, Tallyfy helps you [reassign their tasks](/products/pro/settings/org-settings/how-can-i-remove-a-member-from-my-tallyfy-organization/) to other team members. Deactivated members no longer count towards your account limits. #### Important deletion constraints Before deactivating members, be aware of these system protections: - **Default Administrator**: Cannot be deactivated until the role is transferred to another administrator - **Last Administrator**: The final admin in an organization cannot be deactivated - promote another member first - **Two-step process**: Members must be deactivated before permanent deletion from the system - **Task reassignment**: All active tasks and template assignments must be reassigned or handled before deactivation completes If you encounter errors during deactivation, see our [troubleshooting guide](/products/pro/settings/org-settings/troubleshooting-member-deletion/) for solutions. ### Bot/Unbilled status This special status is usually set by Tallyfy admins or support for specific organizational needs: * **Integration Accounts**: Accounts used by software connecting to Tallyfy via the API. * **Partner/Consultant Accounts**: If you use the [Domain Exclusion feature](/products/pro/miscellaneous/how-can-i-become-a-tallyfy-partner/) for partners, their accounts might show as "Unbilled". * **Tallyfy Bot**: Every organization also has a system user named "Tallyfy Bot". This unbilled user posts automated comments (e.g., when a rule triggers a task) and performs system actions where a specific human user cannot be attributed. It cannot be assigned tasks, edited, or deleted. These accounts can access Tallyfy but do **not** count towards your member total. ## Managing member statuses Administrators can view and manage all member statuses in **Settings > Organization > Members**. This central location allows you to: 1. [Invite new members](/products/pro/documenting/members/how-to-invite-and-activate-members-on-tallyfy/) (they start as Invited). 2. [Deactivate members](/products/pro/settings/org-settings/how-can-i-remove-a-member-from-my-tallyfy-organization/) (changes status to Deactivated). 3. See the current status of everyone listed. Understanding these member statuses helps you effectively manage user access permissions and optimize your Tallyfy account. ### Personal settings - **[Delete your account](https://tallyfy.com/products/pro/settings/personal-settings/how-can-i-cancel-and-delete-my-tallyfy-account/)**: To permanently delete a Tallyfy account administrators must access Settings navigate to Billing click DELETE ACCOUNT and complete an official closure form with the correct Organization ID which results in irreversible deletion of all organizational data processes and user information. ## Permanently deleting your Tallyfy account If you need to permanently close and delete your Tallyfy organization, follow these detailed steps carefully. **Please note this action is completely irreversible and cannot be undone.** :::warning[Deletion is permanent and irreversible!] * Once your account is deleted, all your organizational data, processes, templates, and user information will be **permanently and irreversibly deleted**. No data can be restored after deletion. * You **must** submit the official closure form using the specific link provided above. Informal requests (like emails to support requesting deletion) will not be processed due to strict privacy and security policies. ::: ### Data retention after deletion - **30-day export window**: Ensure you export needed data before final deletion - **90-day backup retention**: Recovery may be possible via [support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/) - **Permanent deletion**: After 90 days, all data is irreversibly removed :::note[Non-payment closures] The same 30-day/90-day timeline applies to accounts closed due to non-payment. ::: After you submit the official closure form, a Tallyfy team member will review and process your request, then confirm when the deletion has been completed. All billing for the account will also be permanently stopped. - **[Change my email address](https://tallyfy.com/products/pro/settings/personal-settings/how-can-i-change-my-email-address-in-tallyfy/)**: This guide explains how to update your Tallyfy login email address through profile settings for regular accounts or through a member transition process for SSO and social login users who cannot directly change their email credentials. ## Updating your login email address Your email address serves as your Tallyfy login credential. This guide explains how to safely change your email address. :::note[Special process for SSO and social signup users] If you originally signed up or sign in using [Single Sign-On (SSO)](/products/pro/integrations/authentication/) or social login (Google, Microsoft), you cannot change your email address directly. This is because these users authenticate through external providers and don't have passwords in Tallyfy. You'll need to follow the [member transition process](#sso-and-social-login-users) outlined at the bottom of this article. ::: ### Prerequisites * You must be logged in to your Tallyfy account using your current email address * You need access to *both* your current and new email inboxes for verification purposes * You must have signed up with a regular email and password (not SSO or social login) ### Steps to update your email address ### Verifying and using your new email address :::note[Limits on email changes] For security reasons, you can only change your email address 3 times per day on free plans. Paid plans don't have this restriction. Contact support if you need to exceed this limit. ::: ### Troubleshooting * Double-check that you typed the new email address correctly without any typos * Confirm you can receive emails at the new address (check spam folders thoroughly) * If you cannot log in after changing the email, [contact Tallyfy Support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/) and provide both your old and new email addresses for assistance ## SSO and social login users If you signed up or sign in using [Single Sign-On (SSO)](/products/pro/integrations/authentication/) or social login (Google, Microsoft), changing your email address requires a different approach. You cannot update the email address directly because these users authenticate through external providers and don't have passwords in Tallyfy to verify their identity. ### Changing email for SSO/social login accounts This process ensures all your tasks, permissions, and workflow assignments transfer properly from the old email address to the new one while maintaining the security of your SSO or social login authentication. ### Why this process is necessary SSO and social login accounts authenticate through external identity providers (like Google, Microsoft, or your company's SSO system) and don't have passwords stored in Tallyfy. Since email changes require password verification for security, these users cannot use the direct email change feature. The member transition process ensures proper task inheritance while working around this technical limitation. - **[Reset your password](https://tallyfy.com/products/pro/settings/personal-settings/how-can-i-change-or-reset-my-tallyfy-password/)**: Tallyfy users can change their password through profile settings when logged in or reset it via email link when forgotten with passwords requiring 8+ characters including uppercase lowercase letters and numbers while authentication loops can be fixed by visiting the logout URL to clear browser sessions. ## Changing or resetting your Tallyfy password There are two primary methods to update your Tallyfy password: 1. **Change it while logged in** (if you know your current password) 2. **Reset it if you forgot it** (if you cannot log in to your account) ### Changing password while logged in ### Resetting a forgotten password If you cannot log in because you forgot your password: ### Password requirements For enhanced security, your Tallyfy password must: - Contain at least 8 characters in total - Include at least one uppercase letter (A-Z) - Include at least one lowercase letter (a-z) - Include at least one number (0-9) - Be different from your previous password :::note[Limits on password changes] For security reasons, you can only change or reset your password 3 times per day. If you need assistance beyond this limit, please contact support. ::: ### Troubleshooting password reset - Ensure you enter the correct email address associated with your Tallyfy account - Verify if the reset link has expired (it remains valid for 24 hours) - If you don't receive the reset email (after checking spam folders), [contact Tallyfy Support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/). Please provide your name, company name, and the email address you believe is linked to the account ### Fixing authentication loops If you experience loops where password reset redirects you to create a new account or keeps asking for credentials repeatedly, your browser session needs to be completely cleared. **Quick solution**: Visit [https://account.tallyfy.com/logout](https://account.tallyfy.com/logout) to force a complete logout, then: :::tip[Why this happens] Authentication loops during password reset typically occur when: - Your account type (especially Light members) isn't properly recognized - Browser sessions from previous login attempts conflict with the reset process - Cookies from multiple organizations cause session confusion The logout URL clears all these conflicting sessions at once. ::: - **[Manage email notifications](https://tallyfy.com/products/pro/settings/personal-settings/how-can-i-manage-email-notifications-in-tallyfy/)**: Tallyfy enables comprehensive email notification customization allowing users to control communication frequency and notification types through profile settings while automatically providing digest reminders for due tasks with options to manually send instant reminders when needed. ## Managing email notifications Tallyfy provides email notification customization enabling precise control over communication frequency and notification types. These personalized notification settings ensure you receive relevant workflow updates while preventing email overload through selective notification management and customizable reminder summary scheduling. To change your settings: 1. Click your profile picture/name (top right) > **Settings**. 2. Go to **My Profile** > **Email Notifications** tab. Here you can turn different notification types ON or OFF using the toggles. For example, if you don't want an email every time a task you assigned is completed, turn that notification OFF. ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-change-email-notification-settings.png) :::important[Process initiators and task notifications] **When you start a process where you're also assigned tasks**, you typically won't receive immediate email notifications for those tasks. This prevents email spam when launching processes. **Why this happens**: - The system assumes you're aware of tasks you just created by launching the process - Prevents duplicate notifications (one for launching, one for each task) - You'll still see tasks in your dashboard immediately **To ensure you get reminders**: - Enable daily digest emails in your settings - Set appropriate deadlines on tasks - Other assignees will receive immediate notifications as normal **Special case - Zapier-initiated processes**: If a process is started via Zapier automation with you as the process starter, you won't receive task notifications either. This can leave you "in the dark" about automated tasks. Workaround: Have Zapier assign a different user as the process starter, or use webhooks to trigger external notifications. ::: ### Email reminder settings (digest emails) Tallyfy automatically sends email digests reminding you and guests about tasks that are due soon or overdue. * **Frequency**: In your Email Notification settings, you can choose which days of the week you want to receive this reminder digest email. * **Cannot turn off completely**: For important task tracking, you cannot completely turn off these reminder emails. You must choose at least one day per week to receive the digest. * **Check individual settings**: If someone says they aren't getting reminders, ask them to check their settings on this page first. Remember, even if someone has reduced their automatic reminders, you can always [manually send an instant reminder](/products/pro/tracking-and-tasks/tasks/how-can-i-send-email-reminders-in-tallyfy/) for a specific task. :::note[Future Possibility: Interactive Emails] In the future, Tallyfy is [exploring interactive email actions](/products/pro/integrations/interactive-email-actions/) that could allow you to complete certain quick tasks directly from within some email clients, potentially making these notifications even more actionable. ::: - **[Update your profile picture](https://tallyfy.com/products/pro/settings/personal-settings/how-can-i-set-up-my-profile-photo-on-tallyfy/)**: You can upload or change your profile picture in Tallyfy by accessing Settings then My Account Profile and clicking the CHANGE PHOTO button to select and upload an image file from your computer. ## Uploading or changing your profile picture Adding a profile picture helps your teammates recognize you in Tallyfy. Your picture appears next to tasks you're assigned to and in some system emails. This visual identification improves team collaboration and communication. Here's how to add or change your photo: Your new photo will now appear throughout Tallyfy, helping teammates easily identify your contributions and assignments. - **[Switch between organizations](https://tallyfy.com/products/pro/settings/personal-settings/how-can-i-switch-between-organizations-in-tallyfy/)**: Users with multiple Tallyfy organization associations can switch between different accounts by clicking their profile picture and selecting Switch Organizations to access any organization where they hold membership. ## Switching between organizations If your Tallyfy login (email address) is associated with multiple Tallyfy organizations (e.g., your company and a client account), you can seamlessly switch between them. This feature allows you to work efficiently across different accounts using just one Tallyfy login credential. - **[Personalization settings](https://tallyfy.com/products/pro/settings/personal-settings/personalization-settings/)**: Tallyfy personal and profile settings can be accessed through Settings > My Account where users can customize display preferences like language and time zone in the personalization tab and update personal information including profile picture name email and job title in the profile tab. ## Managing personal and profile settings You can customize various aspects of your Tallyfy experience to suit your individual preferences. To access these settings: You'll find several important tabs available here: ### Personalization settings This tab allows you to customize how Tallyfy displays information specifically for you: * **UI Language**: Select the display language for Tallyfy menus and buttons (this does not translate task or template content) * **Time zone**: Configure your local time zone so deadlines and timestamps appear correctly for your location * **Date format**: Choose your preferred date format (e.g., MM/DD/YYYY or DD/MM/YYYY) * **Date display**: Choose whether dates appear as **Relative** (e.g., "Tomorrow", "In 2 days") or **Hard Dates** (e.g., "2023-10-27") * **Sounds**: Enable or disable task completion sounds for audio feedback ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-personal-settings-personalization.png) ### Profile settings This tab enables you to update your basic personal information: ![](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-personal-settings-profile.png) * **Profile Picture**: Upload or change your personal photo * **Name**: Edit your first and last name information * **Email**: [Change your login email address](/products/pro/settings/personal-settings/how-can-i-change-my-email-address-in-tallyfy/) * **Job Title**: Update your current job title * **Phone Number**: Add or modify your phone number * **Country**: Update your country location * **Team Name**: Enter your team's name (this is a text field only, it doesn't link to Tallyfy groups) * **Password**: [Change your login password](/products/pro/settings/personal-settings/how-can-i-change-or-reset-my-tallyfy-password/) (requires knowing your current password) Always remember to click **Save Changes** after updating any profile information to ensure your changes are preserved. --- ## Metadata - **Generated**: 2026-02-03T23:55:21.620Z - **Total Documents**: 546 - **Products**: Answers, Denizen, Manufactory, Pro - **Format**: llms.txt v1.0 (full content) - **Source**: https://tallyfy.com/products/ ## Social Media - [LinkedIn](https://www.linkedin.com/company/tallyfy/): Follow Tallyfy on LinkedIn ## Related Resources - [Main Website llms.txt](https://tallyfy.com/llms.txt): Blog posts and marketing content