# 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 combines semantic understanding with keyword matching so users can find information through natural language queries. It offers built-in neural capabilities and simpler deployment than Elasticsearch, Algolia, or similar solutions. ## 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 - Don't 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's 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 pricing](https://tallyfy.com/products/answers/pricing/)**: Contact the Tallyfy team to learn about Answers neural search pricing and capabilities. Get details and custom solutions for your specific search needs. ## Contact us about Tallyfy Answers neural search Reach out to us if you'd like to learn more about Tallyfy Answers neural search. We'll share details and custom solutions that fit your search needs. [^1]: You'll see significant cost savings through optimized vector search and shared infrastructure - **[Collections](https://tallyfy.com/products/answers/collections/)**: Collections in Tallyfy Answers group similar objects together, like database tables. They support searching, filtering, and managing data with automatic schema detection and full CRUD operations. ## What are collections in Tallyfy Answers? Collections in Tallyfy Answers 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 - **Scale**: Collections can hold thousands of objects[^2] - **Metadata**: Store and get information about the collection itself ### What operations can you perform on collections? Here's what you can do with Tallyfy Answers collections: - [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 - **[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, search combines AI understanding with keyword matching to find 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? Here's how to search: ```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 processes long-running operations like batch imports in the background without blocking API requests. Monitor task progress and cancel jobs as needed. ## 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 - **[Objects](https://tallyfy.com/products/answers/objects/)**: Objects are JSON data records in Tallyfy Answers that belong to collections. They can be indexed, retrieved, and searched using custom or auto-generated unique identifiers. ## 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 ### Collections - **[Create a collection](https://tallyfy.com/products/answers/collections/create-collection/)**: Create collections in Tallyfy Answers using a POST request to the /v1/collections endpoint. Each collection needs a unique name and supports automatic data type detection. ## How do you create collections in Tallyfy Answers? Before adding objects to Tallyfy Answers, you'll need to 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 Your request body should contain a JSON object with these collection properties: | Parameter | Type | Required | Description | |-----------|------|----------|-------------| | `name` | string | Yes | Unique name for the collection (can include letters, numbers, hyphens, and `_`) | | `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 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 `_` - Choose descriptive names that reflect the content (e.g., "products", "users", "articles") - Don't use spaces or special characters - Keep collection names concise but meaningful - Use consistent naming conventions across all collections [^1]: HTTP status indicating successful resource creation. It's distinct from 200 OK, which applies to 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. Consider alternatives like data export or backup before execution. ## Deleting collections This endpoint lets you 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 can't be undone, and there's 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, you might 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[^2] 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 all collections in your Tallyfy Answers account, sorted by creation date. Use limit and offset parameters for pagination. ## Listing all collections This endpoint retrieves a summary of all collections in your Tallyfy Answers account. It sorts collections by creation date in descending order[^1] (newest first), so you'll find recently created ones at the top. ### 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 On success, you'll receive 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 many 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/)**: Retrieve information about a specific collection in Tallyfy Answers using its unique name. The response includes metadata, schema details, and object counts. ## Retrieving collection details This endpoint lets you fetch information about a specific collection in Tallyfy Answers using its unique name. You'll get collection metadata, schema information, and object counts in the response. ### API endpoint ``` GET /v1/collections/{collection_name} ``` ### Path parameters | Parameter | Type | Required | Description | |-----------|------|----------|-------------| | `collection_name` | string | Yes | Name of the collection to retrieve | ### Response On success, you'll receive 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 | Schema that's auto-detected 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/)**: Use the PATCH endpoint to modify existing collection properties like descriptions in Tallyfy Answers. Collection names can't be changed, and schema detection stays automatic. ## 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 can't 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 Updating a collection is useful in several situations: - **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 can't be changed after creation - Schema changes happen automatically as objects are indexed[^1], not through this endpoint - Certain system-level properties can't 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/)**: Use the DELETE endpoint to permanently remove objects from Tallyfy Answers collections by unique ID. Returns deletion confirmation, with no recovery option. ## Deleting objects from collections This endpoint permanently removes a specific object from a Tallyfy Answers collection using its unique identifier. Once deleted, you can't recover an object. ### 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 can't be undone. There's no "trash" or "recycle bin" for deleted objects. ::: - Verify 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 removes it from search results immediately - If you need to delete multiple objects, you'll need to make separate API calls for each one - Consider implementing confirmation workflows in your application before calling this endpoint ### Alternative approaches Instead of 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 - **[Get an object](https://tallyfy.com/products/answers/objects/get-object/)**: Retrieve a specific object from a Tallyfy Answers collection using its unique identifier. Returns all object properties including system-generated timestamps. ## Retrieve an object from Tallyfy Answers This endpoint lets you fetch a specific object from a collection using its unique identifier. You'll get 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 request returns a `200 OK` status code and a JSON object with 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" ``` ### Usage notes - It's well suited for displaying detailed information about a specific item - If you're searching across multiple objects, use the [search endpoint](/products/answers/search/) instead - The API returns the complete object with all its properties - System fields like `created_at` and `updated_at` are always included[^1] [^1]: ISO 8601 format timestamps (YYYY-MM-DDTHH:mm:ssZ) tracked at microsecond precision in PostgreSQL - **[Index multiple objects](https://tallyfy.com/products/answers/objects/index-multiple-objects/)**: The batch import endpoint lets you index multiple objects into Tallyfy Answers collections through a single API call. It processes JSON arrays and provides detailed error handling for large-scale data operations. ## Batch importing multiple objects This endpoint lets you efficiently index multiple objects into Tallyfy Answers in a single API call. It's much faster than making individual object creation requests, especially for large datasets or initial data loading. Large batch imports run in the background. You can 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. Here's an example JSON array format for two 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 - **[Index a single object](https://tallyfy.com/products/answers/objects/index-single-object/)**: Add a single object to a Tallyfy Answers collection in real time through a POST request with JSON data. Ideal for individual record creation and testing. ## Indexing individual objects This endpoint lets you 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 much 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 you'll index the object | ### 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 you'll greatly 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/)**: Use the Tallyfy Answers recommendation endpoint to find objects similar to a reference object. Results are ranked by vector distance and similarity score. ## How do you find similar objects in Tallyfy Answers? The recommendation endpoint lets you find objects similar to a specified reference object. This similarity search uses vector embeddings to find objects with related characteristics. It's useful for recommendation systems, content discovery, and finding related items. ### How does similarity search work in Tallyfy Answers? Here's how Tallyfy Answers uses semantic similarity to find related objects: 1. Tallyfy converts each object's text content into vector embeddings (numerical representations) 2. When searching for similar objects, Tallyfy compares vector distances 3. Objects with closer vector distances are more similar 4. Tallyfy ranks results 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 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 - You'll get better recommendations if 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 that delivers royalty-free, location-specific photos based on visitor IP geolocation. It's shown measurable improvements in conversion rates and 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, it's easy to 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 returns royalty-free, location-specific images based on visitor IP address. It offers city-level coverage in the United States and country-level coverage elsewhere, with no authentication required. ## 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. It returns an image matching the detected location ### 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** - Returned when location can't be determined 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 built 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. You don't need attribution in your implementation. ::: ## Performance and support Tallyfy Denizen is built to scale with any amount of traffic. The service uses Cloudflare's global infrastructure so 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 --- ## Pro - **[Introduction](https://tallyfy.com/products/pro/)**: Tallyfy turns business processes into self-running workflows in minutes. Create templates with AI, assign tasks automatically, track progress in real-time, and save 2 hours per employee daily. Tallyfy turns your business processes into self-driving workflows in minutes - without coding or flowcharts. It's built for non-technical people. Tallyfy table view showing a 4-step client onboarding workflow: a person receives signup, AI drafts the welcome email, a manager approves and sends, and a conditional triggers the kickoff workflow Whether you're dealing with small papercuts or big inefficient processes - hundreds of organizations save 2 hours per employee daily with Tallyfy. Simple workflow is a basic human right. Tallyfy makes 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) ## Before and after Tallyfy If you hear any of these phrases at work, that's **busywork** - invisible time you're paying for that produces nothing. Our [ROI calculator](https://tallyfy.com/return-on-investment/) measures the cost of that gap. | If you hear this... | What Tallyfy does instead | |---|---| | "How do I do this?" | Step-by-step guidance is embedded in every task - no manual to read | | "What's the status?" | Real-time progress is visible to everyone, including clients | | "I forgot" | Automatic reminders and assignments - nothing slips | | "What's next?" | The next task auto-routes to the right person | | "See my reminder?" | No chasing - Tallyfy assigns and notifies | | "Where's that file?" | Files, comments, and decisions live inside the workflow | | "Did anyone approve this?" | Approvals happen in-context with a clear audit trail | | "Who's doing this?" | Every task has one clear owner and a deadline | From a decade of Tallyfy implementations, we see organizations typically reclaim a fifth to two-fifths of their work time once those busywork phrases above stop coming up day-to-day. Once you reclaim those hours, the team gets real bandwidth back - to sell more, improve how things actually get done, and invest in research and the kind of work that builds a long-term moat. ### 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** - Stop tasks from being forgotten or done inconsistently. Nothing falls through the cracks. * **Track it** - Track any process in real-time. No more manual status updates and meetings. * **Improve it** - Improve your process easily. Automate certain tasks. * **Delegate** - Auto-delegate to people, automation, or AI. Scale operations and grow margins while improving quality. 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. Together, those workflow failures pile up into the kind of invisible drain on capacity described above. That's a massive waste hiding in plain sight. You can't delegate tasks to AI without agreed processes that people already follow. Without standardized processes, AI becomes guesswork. Tallyfy provides the foundation for AI to deliver practical benefits. ## How Tallyfy works Three steps: document your processes, track them as live workflows, then improve them over time. ### 1. Document Tallyfy centralizes all business procedures where they're actually used - inside active workflows. Capture every task, how to do it, who's doing it, and by when. Document your process in minutes, like a recipe - using AI in 60 seconds or by importing existing SOPs. ### 2. Track Instantly turn what you documented into a running workflow. Launch with one click - processes run themselves. Track [task](/products/pro/tracking-and-tasks/tasks/) progress and capture data in real-time (clients love this). Tallyfy handles reminders automatically. Trackable workflows cut status meetings by **80%** while making sure work gets done right every time. Your clients can be assigned work and see progress too. ### 3. Improve Delegate selected tasks to [automations](/products/pro/documenting/templates/automations/), scripts, or AI using simple "if this then that" rules that any business user can configure in three clicks. Compound the value of improvements in your repeatable processes over time. You can't improve or automate chaos. Tallyfy makes processes visible, measurable, and **40% faster on average**. ## Best-fit processes Tallyfy works best 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 80% of business processes live in email, chat, and spreadsheets. Tallyfy replaces that mess with workflows that run themselves: - **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 with client-facing workflows that impress - **Zero dropped balls** - Automatic handoffs don't fail - **40% faster processes** - Data-driven improvements compound - **10-minute setup** - Transform processes into reusable [templates](/products/pro/documenting/templates/) - **Eliminate 90% of follow-up emails** - Notifications happen automatically ### 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 don't formally complete - **[Conditional logic automation](/products/pro/documenting/templates/automations/conditional-visibility-guide/)** - IF-THEN rules that show or 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 - conditional branching, auto-assignments, and deadline actions - **Self-driving processes** that 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 - just click the **Complete** button in that task. If the **Start Process** button appears grayed out, complete the onboarding tasks first. This helps 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 cover everything: - **[Procedure templates](/products/pro/documenting/templates/)** - Multi-step workflows (onboarding drops from 5 days to 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] ![Example template in Tallyfy showing workflow steps](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 that simple: ### 3. Track progress Tallyfy runs workflows on autopilot: - Assigns [tasks](/products/pro/tracking-and-tasks/tasks/) based on workload - Sends updates only when needed (no spam) - Shows live progress to everyone - Never drops handoffs ![Ongoing process view showing task progress and assignments](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-showing-ongoing-process.png) ![Individual task view within a running process](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 fills in the details in seconds: ![Creating a client onboarding template using Tallyfy AI](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-create-client-onboarding-template-from-tallyfyAI.png) #### Make steps clear Start each step with an action verb: - Good: "Email the estimate to the customer within 24 hours" - Vague: "Handle customer communications" #### Add helpful media Include images or videos for complex instructions: ![Adding images or videos to task 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): ![Switching a task type to approve or reject](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-switch-to-approvereject.png) #### Assign clear responsibility ![Assigning a task to a team member](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-assign-a-task-to-somebody.png) #### Set realistic deadlines ![Setting a deadline on a task](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-specify-deadline-to-task.png) #### Use automation rules Apply conditional logic: ![Accessing automation rules for a template](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/): ![Adding kick-off form fields to a template](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-how-to-add-kickoff-forms.png) ### Creating effective documents [Document templates](/products/pro/documenting/documents/) let you create forms for use across the platform. #### Add fields Click **New Field** for various [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/): ![Adding a new field to a document template](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-add-field-document.png) #### Reuse existing fields Ensure consistency: ![Selecting an existing field to reuse in a document template](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 more "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 can save 10 hours weekly. [^1]: Based on Hermann Ebbinghaus's research - without reinforcement, 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 need IT departments for setup, Tallyfy's automation rules can be configured by any business user in a few clicks using simple if-then logic. [^3]: This 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 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. Updating a compliance disclaimer in one place automatically updates it across all documents and active processes. [^6]: Powered by Azure Cognitive Services, this auto-translates task instructions, forms, and process documentation into the user's preferred language while maintaining context and technical accuracy. ### Pro - **[By role](https://tallyfy.com/products/pro/by-role/)**: Tallyfy works differently depending on what you do day to day. Pick your role - editor, member, or guest - to jump straight to a short, curated guide of the articles that matter most to you, instead of reading the whole manual. Tallyfy works differently depending on what you actually do. Pick your role below and you'll land on a short, curated guide that answers your real questions. No need to read the whole manual. ## Switch anytime The full manual is always in the sidebar. These role guides are just a faster way in, and plenty of people wear more than one hat. If you build workflows *and* complete your own tasks, start with the editor guide and dip into the member guide when you need it. - **[Compliance](https://tallyfy.com/products/pro/compliance/)**: Tallyfy maintains a current SOC 2 Type 2 attestation. Bank-level encryption (TLS 1.2+ and AES-256), immutable audit trails, and SSO enforcement serve regulated industries like financial services, healthcare, and manufacturing that need documented proof of who did what and when. ## Security and compliance overview Tallyfy is SOC 2 Type 2 certified with bank-level encryption, SSO enforcement options, and complete audit trails for regulatory needs. As an [independent, profitable company](/products/pro/miscellaneous/about-tallyfy/), we invest heavily in security. ### SOC 2 Type 2 attestation Tallyfy maintains a current SOC 2 Type 2 attestation. For the audit period, scope, and how to request the report under NDA, see [Tallyfy's SOC 2 page](https://tallyfy.com/legal/soc-2-type-2/). ### Audit trail Tallyfy tracks all workflow actions automatically - who did what, when, and what changed. #### What's tracked - **Timestamped steps:** Every step records the user, time, and outcome - **Immutable records:** Audit records can't be deleted or modified, not even by admins - **Activity logging:** Full visibility into every user action - **Exports:** Generate audit reports for regulatory compliance - **Template version control:** Track all template changes with author and reason #### Regulated industries using Tallyfy **Financial services:** - Asset management firms meeting SEC Rules 204-2 and 206(4)-7 - Banks complying with FINRA audit requirements - Insurance companies tracking claim decisions and approvals **Healthcare and life sciences:** - Pharma companies following FDA 21 CFR Part 11[^2] - Clinical research teams meeting ICH E6(R3) standards - Medical device manufacturers proving ISO 13485 compliance - Healthcare IT maintaining HIPAA audit logs **Manufacturing and safety-critical industries:** - Auto manufacturers tracking part changes for IATF 16949:2016 - Aviation maintenance shops meeting FAA AC 145-9A - Nuclear facilities following 10 CFR 50 Appendix B - Chemical plants meeting OSHA Process Safety Management requirements **Infrastructure and utilities:** - Power companies handling NERC CIP cybersecurity audits - Railroads documenting track inspections per 49 CFR 213 - Mining operations proving MSHA workplace examinations All these industries need documented proof of "who did what, when." See [industry-specific workflow applications](/products/pro/tutorials/industry-specific-workflow-applications/) for details. ### PCI-DSS considerations **Tallyfy isn't PCI-DSS certified** - we don't process payment card data directly. You can still use Tallyfy in PCI-compliant environments: - **Never store card data in Tallyfy** - don't enter credit card numbers, CVVs, or payment data in form fields - **Use tokenization** - store only tokenized references from your payment processor - **Use compensating controls** - Tallyfy's audit trails and access controls support your PCI compliance program - **Separate systems** - keep payment processing separate from workflow management Consult your QSA (Qualified Security Assessor) about including Tallyfy in your cardholder data environment. ### Security governance Tallyfy applies enterprise security principles across the product. #### Identity and access management - **Least privilege:** Users only access workflows relevant to their role (Admin, Standard, or Light) - **Role-based access:** Three distinct permission levels control what each user can see and do - **Access reviews:** Regular permission audits for users and admins - **Environment segregation:** Full separation between development, test, and production #### Single Sign-On enforcement Tallyfy can restrict login exclusively to your SSO provider. SSO-only mode means: * All logins go through your SSO provider only * Email-password login is disabled organization-wide * User management stays centralized in your identity provider Administrators turn SSO-only mode on themselves under **Settings > Organization > Security**, once your organization has a verified domain. See [SSO enforcement and break-glass](/products/pro/integrations/authentication/sso-enforcement-and-break-glass/) for the walk-through and the recovery options if your identity provider goes down. :::note[Advanced SSO for AI integrations] If you're using AI workflows, [SSO integration with MCP servers](/products/pro/integrations/mcp-server/sso-authentication/) extends identity governance to AI-powered applications - centralized authentication across both workflow systems and AI tools. ::: #### Data security - **Transport encryption:** TLS 1.2+ for all data in transit - **At-rest encryption:** AES-256 for stored data on AWS servers - **Tenant isolation:** Complete data separation between organizations #### Operational security - **Vulnerability testing:** Annual penetration testing plus automated security scanning - **Change control:** All code changes go through development, testing, review, and approval before production - **Continuous monitoring:** AWS CloudWatch and GuardDuty provide 24/7 monitoring with alerting - **Incident response:** Documented and tested security incident response procedures #### Third-party risk - **Vendor assessment:** Security vetting required for all vendors with regular reassessments - **Supply chain oversight:** Regular review of AWS SOC 2 reports and vendor security documentation --- [^2]: Federal regulation for electronic records and signatures in pharmaceutical and medical device industries - **[Launching](https://tallyfy.com/products/pro/launching/)**: Tallyfy lets you launch reusable templates into independent trackable processes, each with its own name, deadlines, and assignments. Choose from six methods including manual clicks, API calls, email triggers, and magic links. Template edits only affect future launches and never alter already-running work. ## Process launching in Tallyfy Launching turns a template into a live, trackable process with assignments and deadlines. Each launched process runs independently - its own timeline, participants, and progress. Templates are reusable blueprints. Processes are specific instances of those blueprints. Think of it like printing a document - the file stays the same, but each printout lives on its own. ### Templates vs. processes * **Templates** - Reusable workflow designs with standardized steps (e.g., "Client Onboarding" template) * **Processes** - Running instances for specific cases (e.g., "Coca-Cola Client Onboarding" launched today) Give each process a descriptive name so you can track multiple running instances at a glance. :::note[Template vs. blueprint] In the Tallyfy app, we use the term **Template**. In the API, the same concept is called a **Blueprint** (internally `checklist`). ::: ### Key concepts #### Process independence from template changes Template edits only affect future launches. Running processes keep their original instructions - they won't change mid-flight. This protects active work while letting you improve templates continuously. :::tip[Adding tasks to running processes] You can add extra one-off [tasks](/products/pro/tracking-and-tasks/tasks/) to a process *after* it's launched. You aren't limited to the steps 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 (via automated actions) * **Web form integration** - Through kick-off form submissions * **Email triggers** - Send messages to designated addresses * **Magic links** - External people can start processes without logging in #### How launch methods work together All six methods converge to create an active process from a template. [Diagram removed for brevity] **Diagram description:** Six launch methods all create the same result - an independently running process with its own timeline and assignments. **What to notice:** - All six methods produce the same outcome - an active process instance - You can customize settings before each launch regardless of the method - The template stays unchanged while each process runs on its own #### Customization during launch When launching, you can: * Set a process name (up to 550 characters) * Change task assignments (members, groups, or guests) * Adjust deadlines per task * Pre-fill kick-off form fields with relevant data * Assign the process to folders and add tags You can also [set up auto-naming](/products/pro/tracking-and-tasks/processes/edit-processes/how-can-i-auto-name-a-process-in-tallyfy/) to generate process names from kick-off form field values automatically. - **[Integrations](https://tallyfy.com/products/pro/integrations/)**: Tallyfy connects with your existing business software through many methods, from a full REST API and webhooks to no-code middleware platforms like Zapier. Sync data and trigger actions across all your tools without manual copy-pasting. ## Why Tallyfy is the AI control layer | What Tallyfy does | Why it matters in the age of AI | |---|---| | Define process steps | You can't automate anything without a recipe. | | Hand small tasks to AI | Massive reduction in mistakes, omissions, and hallucination. | | People approve work | Accountability. You can't blame AI for mistakes. | | Hybrid people + AI tasks | AI can't do every task in a process. | | Track real-time status | Tracking AI sessions at scale is a nightmare. | | Gradually shift tasks to AI | A total re-do will break a process that works today. | ## AI-ready integrations Tallyfy gives you three AI-ready ways to connect, and they work together. Pick by how you want the AI to act. - **Middleware connectors** run fixed, repeatable automations. A [connector](/products/pro/integrations/middleware/) like Zapier, Power Automate, or n8n launches a process or completes a task the moment something happens in another app. Best when you know exactly what should happen every time. - **The [MCP server](/products/pro/integrations/mcp-server/)** lets an AI assistant (ChatGPT, Claude, Gemini, or Microsoft Copilot) run Tallyfy in plain English. Ask it to find a task, launch a process, or tidy up a template, and it does the work. Best for conversational, one-off, or judgment-based requests. Setups like [Microsoft Copilot Studio](/products/pro/integrations/mcp-server/microsoft-copilot-studio/) bring the same server into the Microsoft stack. - **[BYO AI](/products/pro/integrations/byo-ai/)** puts your own AI subscription to work inside a workflow step. When a task lands, your AI reads the context and drafts, decides, or completes it. Best for embedding AI directly in the day-to-day run of a process. All three follow your existing Tallyfy permissions on every action, and you can mix them. See the [connector capability matrix](/products/pro/integrations/middleware/connector-capability-matrix/) for what each connector covers, or [BYO AI](/products/pro/integrations/byo-ai/) for the simplest setup using an AI subscription you already pay for. ## 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 tools](https://screenshots.tallyfy.com/illustrations/integrations-overview.jpeg) Tallyfy connects with your existing business software through multiple methods - from simple email integrations to full API implementations. Pick what works for your team, whether you've got developers or prefer clicking buttons instead of writing code. ### Why integrate? Without integrations, you're stuck copying and pasting data between systems all day. Integrations automatically share data between systems, trigger actions across platforms, and keep everything in sync. ### Available integration methods | Integration method | Skill required | Primary benefit | Best for | |---|---|---|---| | Open API | High (Development) | Complete control, custom solutions | Custom integrations with full flexibility | | Tallyfy CLI | Medium (Command line) | Scriptable automation and bulk actions | Terminal commands, scripts, and CI/CD pipelines | | 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 | Low (OAuth setup) | Use your AI subscription in tasks | Automate decisions and content generation | | Computer AI Agents | Medium (Setup) | Automate UI interactions | Legacy systems without APIs | | Native Integrations | Low (Configuration) | Plug-and-play 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) | Workflow data insights | Business intelligence and reporting | | Chat Platform Tools | Low (App installation) | Task management within chat | Teams using Slack/Teams heavily | | Azure Translation | Medium (Azure setup) | Real-time content translation | Multilingual and global teams | | Open Source Resources | Medium-High (Development) | Code examples and community support | Developers seeking implementation guidance | | Idempotency Handling | Medium-High (Architecture) | Prevent duplicate operations | API and webhook integrations needing reliability | ### 1. Open API integration Tallyfy's REST API gives developers complete control: - Build custom apps using Tallyfy workflow data and functionality - Exchange data bidirectionally between Tallyfy and external systems - Launch, update, and monitor workflows programmatically - Manage users, permissions, and org settings through code ### 2. Command line interface (CLI) The [Tallyfy CLI](/products/pro/integrations/cli/) brings Tallyfy to your terminal and your scripts: - Launch one process or hundreds from a single CSV file - Export and import templates as JSON kept in version control - Hold a CI/CD pipeline until someone completes an approval task - Install with Homebrew or a direct download on macOS, Windows, and Linux ### 3. Webhooks Webhooks notify external systems the moment something happens in Tallyfy - a task completes, a process launches or finishes, and more. - Get instant notifications when tasks complete or processes launch/finish - Automatically send form data to downstream applications - Trigger actions in external systems based on Tallyfy events - Configure webhooks at template and step levels for targeted notifications :::tip[Webhook setup and testing] **Setting up webhooks**: Open your template, click on any step, and add your webhook URL in the webhook field. You can also set webhooks via automated actions. 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 wiring up real integrations 5. Task-level webhooks fire when tasks complete. Process-level webhooks fire when a process is launched or completed. **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 the process starts ::: ### 4. Middleware platforms Can't code? No problem. Middleware platforms like Zapier, Make, and Power Automate connect Tallyfy to thousands of apps through visual, drag-and-drop interfaces: - Use pre-built connections without writing code - Create integrations using visual workflow builders - Transform data formats between systems automatically - Build conditional logic (IF-THEN rules) for smarter workflows **Examples:** Zapier, Microsoft Power Automate, Make.com, Workato, Tray.io ### 5. BYO AI integration [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 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 higher-volume or more complex connections, **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. ::: ### 6. Computer AI agents Got ancient software with no API? Computer AI Agents can control it like a human would - interpreting screens, clicking buttons, and filling forms automatically. Good for: - Legacy systems without APIs - Dynamic web pages that change frequently - Multi-step tasks requiring screen context understanding - Systems where traditional API integration isn't feasible **Examples:** Claude Computer Use, Twin.so, Skyvern, Manus AI :::note[Starting with computer AI agents] Computer AI Agents work best for **short, repetitive tasks**. Don't start with complex, goal-driven jobs - they can be expensive and unpredictable. Focus on simple data entry, form filling, or information extraction first. ::: ### 7. Native integrations built by Tallyfy Pre-built connections Tallyfy maintains for specific platforms: - Official support and testing by Tallyfy - Simpler setup than custom integrations - Automatic updates maintained by Tallyfy - Direct support if issues arise ### 8. Email integration Everyone has email - that's why email integration works so well: - 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 from your inbox - Connect with any standard email system **Featured:** [Gmail plugin](https://workspace.google.com/marketplace/app/tallyfy/671710262095) for managing workflows in Gmail. ### 9. Analytics connection Want to know where your processes get stuck? Tallyfy Analytics exports process data for analysis with BI 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 bottlenecks through performance analysis ### 10. Chat platform integration (e.g. Slack) Your team lives in Slack? Keep them there: - Create Tallyfy tasks directly from chat messages - Launch processes without leaving your chat app - Receive status updates in relevant channels - Link conversations to related tasks **Featured:** [Slack plugin](https://go.tallyfy.com/api/functions/slack/oauth2/install) for managing tasks in Slack. ### 11. Azure translation services Got team members in Tokyo, Paris, and Sao Paulo? Azure Translation breaks down language barriers: - Translate task instructions and comments in real-time - Let team members work in their preferred language - Allow each user to set individual language preferences - Use Microsoft's AI-powered translation technology - 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. ### 12. Open source resources for developers Check out Tallyfy's [GitHub](https://github.com/tallyfy/api-support) repository for: - Sample code for common integration tasks - Helper scripts and utilities - Technical implementation guides - Examples you can adapt for custom solutions ### 13. Idempotency handling for reliable integrations Duplicate events are a real problem. When building integrations with [Tallyfy's API](/products/pro/integrations/open-api/) or [webhooks](/products/pro/integrations/webhooks/), watch out for: - 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 that need 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: interactive email actions] Tallyfy is exploring [interactive email actions](/products/pro/integrations/interactive-email-actions/), which could let users complete certain tasks directly from email clients like Outlook and Gmail. ::: ### 14. AI-powered code generation If your team has developers and clear requirements, AI can draft working integration code fast. Use this 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 (e.g. Python or JavaScript) **How it works** 1. Write a precise spec 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?** Yes - API or AI. No - Middleware. 2. **One-time or ongoing?** One-time - AI. Ongoing - plan for who maintains it. 3. **How complex?** Simple if-this-then-that - Middleware. Complex - API or AI. 4. **Timeline?** This week - Middleware or AI. Have a month - API for maximum control. ### Integration approach comparison | Factor | Direct API | Middleware | AI Code Generation | |---|---|---|---| | **Skill required** | High (developers) | Low (no-code) | Medium (review code) | | **Setup time** | Days to weeks | Hours to days | Hours to days | | **Customization** | Unlimited | Limited by platform | High | | **Maintenance** | Code updates needed | Platform manages | Code updates needed | | **Cost** | Development time | Monthly subscription | AI tool + dev time | | **Best for** | Complex, high-volume | Standard workflows | Custom but quick | ### Can I combine multiple approaches? Yes. Many teams mix and match: - **Middleware + API**: Simple automations in middleware, high-volume or complex work via the API - **AI + Middleware**: AI builds lightweight endpoints, middleware wires them up - **Phased approach**: Start with middleware for speed, 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 the 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. - **Comfortable in a terminal?** Install the [Tallyfy CLI](/products/pro/integrations/cli/) for scripted launches, bulk operations, and CI/CD approval gates. - **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. - **Move fast?** Use AI-powered code generation to scaffold an [API integration](/products/pro/integrations/open-api/) and iterate. - **[Lists](https://tallyfy.com/products/pro/lists/)**: Tallyfy Lists are reusable data tables you define once and reference across all templates and processes. Data like vendor names or product codes stays consistent and up to date without repeated manual entry. ## What are Lists? Lists are reusable data tables in Tallyfy. Create them once, then reference them across any template or process - so you never retype the same data. They're a single source of truth for recurring data like vendor names, product codes, or approval chains. This cuts data entry errors and keeps information consistent across your organization. ### Why use Lists? Stop typing the same vendor names, product codes, or approval chains in every workflow. With Lists, you define that data once and pull it wherever it's needed. Each List is a structured table with custom columns, rows, and individual cells you can update at any time. Changes apply everywhere the List is referenced. ### How Lists connect to other features Lists plug into several parts of Tallyfy: - **Form fields** - Dropdown, multiselect, and radio fields can pull their options directly from a List, so you don't have to maintain options manually - **Templates** - Reference List data for consistent process setup across your organization - **Variables** - Populate variables from List values for dynamic content in your workflows - **Automations** - Use List data in conditional logic and routing rules ### Common use cases - **Vendor directories** - Supplier info, contact details, and procurement approval paths - **Product catalogs** - Item codes, descriptions, and pricing - **Employee roles** - Job titles, departments, and permission levels - **Location data** - Office addresses, regions, and local requirements - **Approval hierarchies** - Management chains and escalation paths - **Compliance requirements** - Regulatory codes, standards, and procedures ### Getting started To set up a List: 1. Create a new List with custom columns for your data 2. Add rows of data - or import from an existing source 3. Connect the List to form fields (dropdown, multiselect, or radio) in your templates 4. Update the List centrally - changes reflect across all linked processes - **[Essentials](https://tallyfy.com/products/pro/documenting/)**: Tallyfy offers three template types. Procedure Templates for tracked workflows with automation, Document Templates for consistent policies with locked sections, and Form Templates for structured data collection. ## Turning static docs into live workflows Tallyfy replaces static documents with live workflows through three template types. Instead of docs that gather dust, [process documentation](https://tallyfy.com/process-documentation/) becomes repeatable, trackable work. You get real-time tracking, performance data, and continuous improvement built in. ### Template types 1. **[Procedure Templates](/products/pro/documenting/templates/)** - Step-by-step workflows, SOPs, and standard procedures. - Best for processes with dependent steps - employee onboarding, purchase approvals, compliance procedures. - Automation rules skip or add steps based on form answers[^1]. - Assign [tasks](/products/pro/tracking-and-tasks/tasks/) to specific [members](/products/pro/documenting/members/) or teams. - Track progress from start to finish. 2. **[Document Templates](/products/pro/documenting/documents/)** - Policy documents, reference materials, and company procedures. - Consistent formatting with flexible content - social media policies, client guidelines, team protocols, compliance documents. - Add [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) so team members fill in specific details while the document structure stays intact. - Lock sections that shouldn't change[^2] - keeps you compliant and on-brand. - Everything's online. No downloads needed. 3. **Form Templates** - Structured data collection *(currently being updated - unavailable)* - Gather business info in one go, without multi-step processes. - Mix question types and form fields for exactly what you need. - Export collected data or send it to other systems. ### Which template type to pick #### Procedure Templates - when you need to: - Track multi-step processes where order matters - Assign different steps to different people or teams - Enforce task completion in sequence (critical for compliance) #### Document Templates - when you need to: - Create reusable documents with consistent formatting - Let people customize details within a locked structure - Build templates for contracts, proposals, policies, or standard communications #### Form Templates - when you need to: - Collect structured data, requirements, or feedback in one shot - Create surveys, questionnaires, or data collection forms - Trigger automated workflows from submissions ### Explore further Check the sidebar for details on 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 - **[Pricing](https://tallyfy.com/products/pro/pricing/)**: Tallyfy offers transparent pricing with annual and monthly billing, two seat types (Full and Light), seat-based billing through Recurly, a Fair Price Guarantee for eligible countries, and nonprofit discounts. ## Pricing overview Tallyfy's pricing is transparent and predictable. As an [independent, sustainable company](/products/pro/miscellaneous/about-tallyfy/), we don't do surprise price increases. See current pricing at https://tallyfy.com/pricing/. ### Annual vs. monthly billing Annual subscriptions cost less per month than monthly billing. You also get budget predictability by paying for 12 months upfront. :::caution[Annual commitment] An annual subscription is a 12-month commitment billed upfront. Cancellations take effect at the end of the 12-month term - no partial refunds or pro-rated credits are issued for unused months within an active annual term. If you're unsure, start with a monthly plan and switch to annual later. ::: ### Member tiers Tallyfy has two member types so you can control costs by matching access levels to what people actually need: | Member Type | Key Ability | |-----------------|--------------------------------------------------| | **Full Member** | Create and edit templates, plus complete tasks. | | **Light Member**| Complete assigned tasks only - can't create or edit templates. | Full Members include both Administrator and Standard roles. :::tip[Save costs with roles] Only give **Full Member** licenses to people who design workflows. Everyone else can use cheaper **Light Member** licenses to complete tasks. ::: :::note[Tallyfy Analytics add-on] * The optional [Tallyfy Analytics](/products/pro/integrations/analytics/) add-on is priced per seat, per year, charged on every committed seat (full and light). * See [billing add-ons and usage credit](/products/pro/settings/billing/billing-add-ons-and-usage-credit/) for how it works. ::: :::note[What's included for free?] All paid Tallyfy subscriptions include: unlimited guests, Single Sign-On (SSO), support consultations, and a 14-day trial. AI-powered workflow features are also included, except on AppSumo lifetime deals. You can request a trial extension through [Tallyfy support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/). Sharing public templates is also free. ::: ### Seat-based billing Tallyfy bills per seat through Recurly. You commit to a number of full and light seats and pre-pay for your term: * **Committed seats** - your plan bills the full and light seats you commit to * **Buy more anytime** - added seats are pro-rated for the rest of your term * **True-down at renewal** - your plan adjusts to the lowest seat count you held during the period * **Invoiced accounts** - manual and multi-entity accounts are billed through Xero by wire or ACH For the full model, see [how seat billing works](/products/pro/settings/billing/how-seat-billing-works/). Accounts payable teams can also pre-fund a balance under the [Terms for Credit Purchase](https://tallyfy.com/legal/terms-for-credit-purchase/). ### Fair Price Guarantee Tallyfy's Fair Price Guarantee gives organizations in eligible countries discounts based on regional GDP per capita. 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 - **Inflation protection**: Your costs stay flat while value increases :::caution[Payment method for Fair Price Guarantee] Your payment method must come from a bank in a qualifying country. For example, Indian companies must pay with Indian bank cards or accounts. ::: ### Nonprofit pricing Certified nonprofits may qualify for special pricing. See the [Nonprofit Discount program](/products/pro/pricing/how-to-apply-for-tallyfys-nonprofit-program-discount/) for details. ### Free and trial options - **14-day free trial** - full feature access, extendable through support - **Free plan** - if costs are a concern, contact support to downgrade instead of canceling. This keeps your data and templates intact. :::tip[Before canceling] Ask support about downgrade options first. Many users don't realize a free tier exists - downgrading keeps your work accessible at no cost. ::: ### Additional capabilities Tallyfy also offers: * Multilingual interface support (included) * AI-powered content localization (requires Azure integration, usage-based billing) * SOC 2 compliance attestation (available on request) * Dedicated support channels * Serverless automation functions (advanced capability) ### Consulting services Tallyfy offers implementation consulting: * Custom workflow template development * [API integration](/products/pro/integrations/open-api/) setup * Change management and user adoption support [Schedule a consultation](https://tallyfy.com/booking/) to discuss custom pricing or implementation help. - **[Tracking](https://tallyfy.com/products/pro/tracking-and-tasks/)**: Tallyfy has two tracking views in the sidebar. Tracker View monitors entire workflows across your organization, while Tasks View is your personal to-do list of assignments and process steps. ## Tracking options in Tallyfy Tallyfy gives you two ways to track work - both in the left sidebar. Understanding [what a workflow is](https://tallyfy.com/what-is-a-workflow/) helps you get the most from them. * **Tracker View** - Shows all running [processes](/products/pro/tracking-and-tasks/processes/) at a glance. See which workflows are on track and which need attention across your organization. * **Tasks View** - Lists every [task](/products/pro/tracking-and-tasks/tasks/) you need to complete - whether it's part of a process or a standalone assignment. Your personal to-do list. ### Why two different views? The Tracker view is for monitoring entire workflows. The Tasks view is for getting work done. Think helicopter view versus street level - both matter at different times. - **[Settings](https://tallyfy.com/products/pro/settings/)**: Tallyfy splits settings into Personal Settings that members control (like profile and notifications) and Organization Settings that only admins can change (like billing, branding, and integrations). Each role sees only what's relevant. ## How settings are organized Tallyfy keeps your settings in two places. Personal settings are yours alone. Organization settings cover the whole company, and only admins can change those. Here's what lives where, so you'll know which page to open. - **Personal settings** affect only you. They cover your profile picture, password, email notifications, and language. Any [member](/products/pro/documenting/members/) can change their own. - **Organization settings** affect everyone in your Tallyfy account. They cover billing, member roles, branding, integrations, company-wide preferences, your sign-in setup (single sign-on (SSO) and SAML[^1]), and custom email sending (SMTP). Only administrators can change these. ## What to set up first Not sure where to start? Pick the line that fits you: - **Team members** - open [personal settings](/products/pro/settings/personal-settings/) to set your notifications and preferences. - **Administrators** - open [organization settings](/products/pro/settings/org-settings/) to control options that affect everyone. - **Account managers** - open [billing settings](/products/pro/settings/billing/) to manage your Tallyfy plan and costs. [^1]: Single sign-on lets people use your company's main login, often through SAML, instead of a separate Tallyfy password. - **[Miscellaneous](https://tallyfy.com/products/pro/miscellaneous/)**: Find resources beyond Tallyfy's core workflow tools. Topics include company background, support and troubleshooting, browser compatibility, file storage, search, translation, and legal documentation. ## Additional features and resources This section covers topics and features beyond Tallyfy's core workflow functionality. You'll find topics like: - [About Tallyfy](/products/pro/miscellaneous/about-tallyfy/) - the company and why customers trust us - **[Support](/products/pro/miscellaneous/support/)** - troubleshooting common issues - Browser and device compatibility - 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 partnerships - Legal information like Terms of Service and Privacy Policy Browse all articles using the navigation tree below: - **[Getting started](https://tallyfy.com/products/pro/tutorials/)**: Get started with Tallyfy in under 30 minutes. These step-by-step tutorials cover organization setup, dashboard basics, template creation, and launching your first tracked process. ## Getting started with Tallyfy tutorials Start using Tallyfy in minutes with these step-by-step tutorials. New to workflows? Learn [what is a workflow](https://tallyfy.com/what-is-a-workflow/) first. Each guide walks you through a key feature - from creating your first template to launching automated workflows. **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 in order. Each builds on the previous one. 1. **Create an organization** - Set up your workspace and invite team members (5 min) 2. **Learn the dashboard** - Explore tabs, navigation, and key features (5 min) 3. **Create your first template** - Build a reusable process blueprint (10 min) 4. **Launch your first process** - Turn templates into trackable workflows (5 min) All four take under 30 minutes. You'll have a working process your team can use right away. ### Core skills you'll learn After these tutorials, you'll know how to: * **Build templates** - Create reusable blueprints that standardize any process * **Assign work** - Route tasks to the right people based on roles or workload * **Track progress** - See where each process stands and spot bottlenecks * **Automate decisions** - Set up if-then rules that handle repetitive work * **Collaborate** - Add comments, share files, and keep everyone aligned * **Scale globally** - Support multilingual teams with [translation features](/products/pro/integrations/azure-translation/global-workplace-language-requirements/) These skills work across any department - HR, sales, IT, compliance, 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 go to officers. **Small business outsourcing** - Build repeatable weekly tasks that contractors can follow without training. Freelancers see only their specific tasks - you keep quality while focusing on growth. **Client service management** - Set up workflows where clients submit requests that automatically route to your team. Track status and deliver updates without endless email chains. ### Browse all tutorials by topic ### Getting your team to adopt Tallyfy Here's what works: 1. **Start small** - Pick one process that causes daily pain. Win quick. 2. **Show, don't tell** - Run it 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 Adoption works best when you start with a painful process that affects everyone. ### Evaluating Tallyfy during your trial 1. **Pick a real process** - Don't use hypothetical examples. Choose a workflow you run weekly. 2. **Set success criteria** - Define what "working" means: time saved? Errors reduced? Better visibility? 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, and integrations **Questions to answer during your 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 * **[Templates guide](/products/pro/documenting/templates/)** - Advanced template features like conditional logic and dynamic assignments * **[Automation rules](/products/pro/documenting/templates/automations/)** - 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 help when you need it :::note[Practice as you learn] Follow along in your own Tallyfy account. Each tutorial includes real examples - you'll build actual workflows your team can use right away. ::: ### By role - **[Editor (full seat)](https://tallyfy.com/products/pro/by-role/editor/)**: Tallyfy editors hold a full seat and build the system - creating templates, automating steps, launching processes, tracking progress, and managing people and integrations. This guide links every common editor task to the right article, grouped by what you're trying to get done. You build and run the workflows everyone else uses. A full seat means you can create and edit templates, automate them, launch and track processes, and (if you're an administrator) manage people, billing, and settings. Here's the whole job, grouped by what you're trying to do. ## Set up - **[Create your organization](/products/pro/tutorials/how-can-i-create-a-new-tallyfy-account/)** Get your account and workspace going. - **[Find your way around](/products/pro/tutorials/navigate-tallyfy/)** Templates, Tracker, Tasks, and settings. - **[Invite your team](/products/pro/documenting/members/how-to-invite-and-activate-members-on-tallyfy/)** Add members and pick their roles. ## Build templates - **[Create your first template](/products/pro/tutorials/your-first-template/)** From scratch, from a document, or with Tallyfy AI. - **[Templates explained](/products/pro/documenting/templates/)** Procedure, document, and form templates, and when to use each. - **[Edit a template](/products/pro/documenting/templates/edit-templates/)** Add steps, descriptions, and settings. - **[Assign steps to people](/products/pro/tracking-and-tasks/tasks/edit-task/how-can-i-assign-members-to-tasks-in-tallyfy/)** By person, group, or job title. - **[Choose step types](/products/pro/tracking-and-tasks/tasks/what-types-of-tasks-can-i-create-with-tallyfy/)** Tasks, approvals, expiring steps, and email steps. ## Make it smart - **[Automations explained](/products/pro/documenting/templates/automations/)** The if-this-then-that rules that make a process adapt. - **[Conditions](/products/pro/documenting/templates/automations/conditionals/)** The "if" half: what triggers a rule. - **[Actions](/products/pro/documenting/templates/automations/actions/)** The "then" half: show or hide steps, reassign, set deadlines. - **[Automation examples](/products/pro/documenting/templates/automations/examples/)** Proven patterns you can copy. - **[Variables](/products/pro/documenting/templates/variables/)** Reuse answers from one step across the whole process. - **[Snippets](/products/pro/documenting/templates/snippets/)** Reusable text blocks that update everywhere at once. ## Collect information - **[Form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/)** The inputs people fill in as they work. - **[Kick-off forms](/products/pro/launching/triggers/kick-off-forms/)** Gather what you need before a process even starts. - **[Document templates](/products/pro/documenting/documents/)** Lock standard wording, leave blanks to fill in. ## Launch - **[How launching works](/products/pro/launching/)** Turn a template into a tracked, running process. - **[Launch a process](/products/pro/launching/how-can-i-launch-a-process-in-tallyfy/)** The standard way to start work. - **[Edit before launching](/products/pro/launching/how-can-i-edit-a-process-before-launching/)** Tweak assignments and deadlines for this run only. - **[Other ways to launch](/products/pro/launching/triggers/)** Forms, email, API, magic links, and schedules. ## Track and improve - **[Tracker view](/products/pro/tracking-and-tasks/tracker-view/)** Every running process at a glance. - **[Manage and track processes](/products/pro/tracking-and-tasks/tracker-view/how-can-i-manage-and-track-my-processes-on-tallyfy/)** Spot bottlenecks and keep work moving. - **[Export to CSV](/products/pro/tracking-and-tasks/processes/how-can-i-export-tallyfy-processes-to-csv/)** Pull process data out for analysis. ## People and access - **[Members and roles](/products/pro/documenting/members/)** Administrator, Standard, and Light explained. - **[Manage permissions](/products/pro/documenting/members/how-do-i-manage-member-permissions-in-tallyfy/)** Control who can edit, launch, and view each template. - **[Groups](/products/pro/documenting/groups/)** Assign work to a team instead of one person. - **[Guests](/products/pro/documenting/guests/)** Bring in clients and vendors for free, no account needed. ## Connect your stack - **[Integrations overview](/products/pro/integrations/)** Every way Tallyfy talks to your other tools. - **[Open API](/products/pro/integrations/open-api/)** Build directly against Tallyfy. - **[Webhooks](/products/pro/integrations/webhooks/)** Push events to other systems in real time. - **[Middleware](/products/pro/integrations/middleware/)** No-code automation with Zapier, Make, Power Automate, and more. - **[Single sign-on](/products/pro/integrations/authentication/)** Azure AD, Google, Okta, OneLogin, and JumpCloud. - **[Analytics](/products/pro/integrations/analytics/)** Connect Power BI, Tableau, and other BI tools. ## Administer (administrators) - **[Organization settings](/products/pro/settings/org-settings/)** Org-wide configuration and the audit log. - **[Branding and emails](/products/pro/settings/org-settings/how-can-i-personalize-my-tallyfy-branding-and-emails/)** Make Tallyfy look like yours. - **[Billing and seats](/products/pro/settings/billing/)** Plans, payment, and seat management. - **[How seat billing works](/products/pro/settings/billing/how-seat-billing-works/)** Full seats, light seats, and what you pay for. - **[Guest](https://tallyfy.com/products/pro/by-role/guest/)**: Tallyfy guests are invited by email to complete a task, with no account or password needed. This guide answers the real questions a guest has - finding your task, completing it, filling in fields, asking a question, and seeing everything that's been assigned to you. You were invited by email to do something in Tallyfy. Good news: you don't need an account or a password. Open the link in your email and you're in. Here's everything a guest needs, and nothing extra. ## Get to your work - **[What is a guest, and do I need an account?](/products/pro/documenting/guests/what-is-a-guest/)** No login, no password. You get a secure link to only the tasks meant for you. - **[Find your task link](/products/pro/documenting/guests/how-to-find-a-guest-task-link-in-tallyfy/)** Lost the email? Here's how to get back to your task. - **[See everything assigned to you](/products/pro/documenting/guests/how-can-guests-monitor-their-processes-on-tallyfy/)** One passwordless page lists all your open and finished tasks. ## Finish the task - **[Complete or reopen a task](/products/pro/tracking-and-tasks/tasks/how-can-i-complete-or-reopen-tasks-in-tallyfy/)** Check it off when you're done. - **[Fill in form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/)** Text boxes, dropdowns, dates, file uploads - what each one is and how to complete it. - **[Ask a question or leave a comment](/products/pro/tracking-and-tasks/tasks/how-can-i-manage-comments-in-tallyfy/)** Stuck? Comment right on the task to reach the person who assigned it. ## If something's off - **[I finished a task by mistake](/products/pro/documenting/guests/how-can-i-re-open-a-completed-guest-task/)** Ask the person who assigned it to reopen it for you. - **[Does Tallyfy work on my phone?](/products/pro/miscellaneous/does-tallyfy-work-on-all-devices/)** Yes - phone, tablet, or computer, with nothing to install. - **[Get help from support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/)** Still stuck? Here's how to reach a human at Tallyfy. - **[Member (light seat)](https://tallyfy.com/products/pro/by-role/user/)**: Tallyfy members on a light seat focus on their own work - finding tasks, completing them, filling in form fields, commenting, and tracking the processes they're part of. This guide points you to the right article for each everyday question, without the admin and template-building detail. You complete the tasks assigned to you and keep an eye on the work you're part of. You can't build or edit templates - that's the editor role - and you don't need to. Here's everything you'll actually use. ## Get oriented - **[Create your account and sign in](/products/pro/tutorials/how-can-i-create-a-new-tallyfy-account/)** Set your password, or sign in with Google or Microsoft. - **[Find your way around](/products/pro/tutorials/navigate-tallyfy/)** The sidebar, search, and where your tasks live. ## Work your tasks - **[What tasks are](/products/pro/tracking-and-tasks/tasks/)** The basics: what a task is and how timing and deadlines work. - **[Your to-do list (Tasks view)](/products/pro/tracking-and-tasks/tasks-view/)** Every task assigned to you, in one place. - **[Filter and customize your view](/products/pro/tracking-and-tasks/tasks-view/how-can-i-customize-task-views-in-tallyfy/)** Narrow down to exactly what you need to do next. - **[Complete or reopen a task](/products/pro/tracking-and-tasks/tasks/how-can-i-complete-or-reopen-tasks-in-tallyfy/)** Check it off, or reopen one if you moved too fast. - **[Fill in form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/)** The data you enter as you work through a task. - **[Comments and @mentions](/products/pro/tracking-and-tasks/tasks/how-can-i-manage-comments-in-tallyfy/)** Ask questions and tag teammates right on the task. ## See the bigger picture - **[Track running processes (Tracker)](/products/pro/tracking-and-tasks/tracker-view/)** Watch where the work you're part of stands. - **[What a process is](/products/pro/tracking-and-tasks/processes/)** How a launched workflow differs from a template. ## Notifications and your profile - **[Email notifications and your digest](/products/pro/settings/personal-settings/how-can-i-manage-email-notifications-in-tallyfy/)** Decide what Tallyfy emails you, and when. - **[Set your profile photo](/products/pro/settings/personal-settings/how-can-i-set-up-my-profile-photo-on-tallyfy/)** Put a face to your name. - **[Change your email or password](/products/pro/settings/personal-settings/how-can-i-change-or-reset-my-tallyfy-password/)** Keep your account current and secure. ## Work anywhere - **[Use Tallyfy on any device](/products/pro/miscellaneous/does-tallyfy-work-on-all-devices/)** Phone, tablet, or desktop. - **[Install the desktop app](/products/pro/miscellaneous/how-can-i-install-the-tallyfy-desktop-app/)** Get native notifications even when your browser's closed. - **[Search across everything](/products/pro/miscellaneous/how-to-use-tallyfys-universal-search-function/)** Jump to any task, process, or person. - **[Read SOPs without launching anything](/products/pro/tutorials/knowledge-only-mode/)** When your team publishes reference guides in knowledge-only mode. ### Compliance - **[HSTS compliance](https://tallyfy.com/products/pro/compliance/hsts-compliance/)**: Tallyfy enforces HSTS preloading, so your browser is hardcoded to only use encrypted HTTPS connections. This blocks SSL stripping and man-in-the-middle attacks before any data leaves your device, even on your first visit. HSTS forces your browser to use encrypted connections only. It blocks any attempt to connect to Tallyfy without HTTPS - even if someone tricks you into clicking an `http://` link, your browser upgrades it automatically. ## How does HSTS work? When you first visit Tallyfy over **HTTPS**, your browser receives a `Strict-Transport-Security` header. This tells the browser: "Always use encryption with Tallyfy - no exceptions." Your browser remembers this for one year[^3]. Even if you type `http://` instead of `https://`, the browser catches it before sending any data. ## How does Tallyfy use HSTS preloading? Tallyfy is on the **HSTS preload list[^1]** - hardcoded into Chrome, Firefox, Safari, and other major browsers. Your browser already knows to use HTTPS with Tallyfy **before you even visit for the first time**. There's no window of vulnerability. Not even for a millisecond. ## What attacks does HSTS prevent? * **SSL stripping[^2]:** Attackers try to downgrade your connection to plain HTTP. HSTS blocks this - your browser upgrades to HTTPS before any data leaves your device. * **Man-in-the-middle exploits:** Someone sitting between you and Tallyfy, pretending to be us? Your browser won't accept anything but a verified, encrypted connection. * **Session hijacking:** Login cookies and authentication tokens only travel over encrypted channels. No exceptions. This matters most on public Wi-Fi, where attackers commonly try to intercept traffic. * **Eavesdropping:** Every click, form submission, and document you view is encrypted. Network admins, ISPs, and nearby devices can't see what you're doing in Tallyfy. ## What are HSTS requirements? Tallyfy meets all seven requirements for proper HSTS: 1. **Valid TLS/SSL certificate** - proves you're connecting to the real Tallyfy, not an imposter. 2. **Automatic HTTPS redirection** - any HTTP request gets redirected to HTTPS instantly, so you receive the HSTS header through a secure connection. 3. **All resources over HTTPS** - every image, script, and resource loads over HTTPS. No mixed content. 4. **Secure header delivery** - Tallyfy only sends the HSTS header over HTTPS. Sending it over HTTP would let attackers modify it. 5. **One-year minimum max-age** - browsers remember the HSTS policy for at least a year, so you're protected even after months away. 6. **All subdomains covered** - whether you're on app.tallyfy.com or go.tallyfy.com, HSTS applies everywhere. The `includeSubDomains` directive covers them all. 7. **Preload list inclusion** - Tallyfy is hardcoded into browsers, so new users get protection before their first visit. [^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 31536000 seconds (one year) in the Strict-Transport-Security header - **[BIMI compliance](https://tallyfy.com/products/pro/compliance/bimi-compliance/)**: Tallyfy uses BIMI email authentication with SPF/DKIM/DMARC checks and a Verified Mark Certificate to display its official logo next to legitimate emails in your inbox. This helps you instantly distinguish real Tallyfy messages from phishing attempts and spoofed fakes. Tallyfy uses BIMI to display a verified logo next to emails sent from `tallyfy.com`. If you see the Tallyfy logo in your inbox, that email is genuinely from us. No logo? Don't trust it. ## How does BIMI authentication work? BIMI checks multiple forms of identity before showing our logo next to a message. Here's how it works: ## What security benefits does BIMI give you? * **Instant trust signal:** See the Tallyfy logo? It's really us. No logo on an email claiming to be from Tallyfy? Delete it. * **Faster recognition:** The Tallyfy logo makes our emails stand out in a crowded inbox, so you can spot them quickly. * **Phishing resistance:** Over time, you'll instinctively expect the logo on legitimate Tallyfy emails - making fakes obvious. ## How does BIMI protect against cyber threats? * **Domain spoofing prevention:** Someone sends a fake "password reset" from a spoofed tallyfy.com address. No logo appears, and the email goes to spam. * **Phishing detection:** An urgent "Update your payment method NOW!" email arrives without the Tallyfy logo. That's your red flag - real Tallyfy emails always show the verified logo. * **Brand impersonation resistance:** Scammers can copy Tallyfy's website design, but they can't fake the BIMI certificate. You can immediately spot fraudulent emails by the missing logo. ## 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. Emails sent through custom SMTP come from *your* servers, not Tallyfy's. Email providers check the actual origin, and since the email didn't come from `tallyfy.com`, no logo appears. You'd need your own BIMI setup with your own VMC certificate. ::: To keep the verified logo on your emails, use Tallyfy's default email settings. [^1]: Email authentication protocols that verify sender identity and message integrity [^2]: Verified Mark Certificate issued by certificate authorities to validate logo ownership ### Launching - **[Edit before launch](https://tallyfy.com/products/pro/launching/how-can-i-edit-a-process-before-launching/)**: Tallyfy lets you customize every detail of a process instance during launch. Change names, assignees, deadlines, guest emails, roles, and kick-off form data through a guided wizard without altering the original template. ## How can I edit a process before launching in Tallyfy? You can customize each process instance during launch - changing names, assignees, deadlines, and more - without touching the original [template](/products/pro/documenting/templates/). ### What can you customize before launching? Tallyfy's launch wizard walks you through several steps. Depending on your template's settings, you'll see some or all of these: * **Process name**: Give this instance a unique name (e.g., "Onboard John Smith" instead of just "Employee Onboarding"). Names can be up to 550 characters. * **[Task](/products/pro/tracking-and-tasks/tasks/) assignees**: Change who's assigned to each task for this instance. * **Task deadlines**: Adjust individual task deadlines. * **[Guest](/products/pro/documenting/guests/) emails**: Add or update guest email addresses if the template uses guest assignments. * **Roles**: Assign people or groups to roles defined in the template. * **Kick-off form fields**: Fill in any required kick-off form data before the process starts. * **Tags and folders**: Categorize the process if the template requires tagging or folder placement. :::tip[Auto-naming for consistent process names] You can [set up auto-naming](/products/pro/tracking-and-tasks/processes/edit-processes/how-can-i-auto-name-a-process-in-tallyfy/) to generate process names automatically from kick-off form field values. If auto-naming is on and the template doesn't allow name changes, the name step is skipped entirely. ::: ### How to edit before launching ![Edit process before launch screen in Tallyfy](https://screenshots.tallyfy.com/tallyfy-demo%2fpro%2fdesktop-light-edit-process-before-launch.png) :::tip[Tip for testing] To test a process without notifying the usual assignees, assign all tasks to yourself on the launch screen. This lets you run through every step without bothering your team. ::: These changes only affect the process you're launching now. The original template stays unchanged. - **[Launch manually](https://tallyfy.com/products/pro/launching/how-can-i-launch-a-process-in-tallyfy/)**: Launch a process manually by clicking Launch Process on any template card and naming the instance. You can customize assignees and deadlines before launch, or modify running processes and add ad-hoc tasks afterward. ## Manually launching a process Click **Launch Process** on any template card, give it a descriptive name, and hit **Launch**. That's the core flow. Templates are reusable definitions - processes are the live, trackable instances you create from them. Manual launching gives you full control over timing, naming, and per-instance customization before a workflow starts running. ### Viewing hidden steps in running processes If your process uses conditional rules that hide certain steps, you can still see them. Open the running process and click the **Show hidden tasks** eye icon in the process toolbar. ![Filter button in the process toolbar](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-click-filter.png) ![Show hidden tasks option in the toolbar](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-click-show-hidden-tasks.png) *Note: Hidden tasks won't show descriptions or form fields until their conditional rules activate them.* ### Modifying processes after launching You can change assignees and deadlines on any task after a process is running: ![Changing deadlines on a running process](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-change-deadlines-ongoing-process.png) ### Adding ad-hoc tasks to running processes Need an extra step that wasn't in the original template? You can add tasks on the fly: You can add any task type this way - standard, approval, email, or expiring. ![Adding a task to a running process](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. ::: - **[Launch on a schedule](https://tallyfy.com/products/pro/launching/how-can-i-schedule-a-process-in-tallyfy-using-middleware/)**: Schedule Tallyfy processes to launch automatically on a daily, weekly, or monthly basis. Connect a time-based trigger in Zapier or Make to the Launch Process action. ## Schedule process launches with middleware You can auto-launch Tallyfy processes on a recurring schedule using [middleware](/products/pro/integrations/middleware/) tools like Zapier, Make, or Power Automate. Connect a schedule trigger to Tallyfy's **Launch Process** action, and they'll run hands-free. This guide uses Zapier as an example - the steps are similar in other [middleware platforms](/products/pro/integrations/middleware/). ### What you'll need - A Tallyfy account with the [template](/products/pro/documenting/templates/) you want to schedule - An account with a middleware service (Zapier, Make, or Power Automate) - Your Tallyfy account connected to that middleware service ### Setting it up in Zapier #### 1. Pick the schedule trigger Create a new Zap. For the trigger, search for and select **Schedule by Zapier**. ![Selecting the Schedule by Zapier trigger in a new Zap](https://screenshots.tallyfy.com/zapier-schedule-1.gif) #### 2. Set your schedule Configure when the process should launch: - Frequency - Every Day, Every Week, or Every Month - Specific day (e.g., Monday) or date (e.g., 1st of the month) - Time of day ![Configuring schedule frequency and time in Zapier](https://screenshots.tallyfy.com/zapier-schedule-2.gif) #### 3. Add the Tallyfy action For the action step, pick the **Tallyfy** app and choose **Launch Process**. ![Selecting the Tallyfy Launch Process action in Zapier](https://screenshots.tallyfy.com/zapier-schedule-3.gif) #### 4. Configure launch details Set which process to launch and how: - Select the Tallyfy **Template** to use - **Name** the process instance - include the date so each run is unique (e.g., "Weekly Report - `{{zap_meta_human_now}}`"). Zapier's `{{zap_meta_human_now}}` variable inserts the current date/time. - Fill in any kick-off form fields the template requires ![Configuring Tallyfy template and process name in Zapier](https://screenshots.tallyfy.com/zapier-schedule-4.gif) #### 5. Test and turn on Test your Zap to confirm it's launching the process correctly in Tallyfy. Name your Zap and turn it on. ![Testing and activating the scheduled Zap](https://screenshots.tallyfy.com/zapier-schedule-5.gif) - **[Launch from a form](https://tallyfy.com/products/pro/launching/how-to-launch-a-tallyfy-process-from-a-webform/)**: External web forms can automatically launch Tallyfy processes. Use a public kick-off form link for guest access, or a magic link with pre-filled fields for logged-in users. ## Launch a Tallyfy process from an external web form You can connect an external web form (your website, Typeform, Google Forms, etc.) to Tallyfy so that form submissions trigger a [process](/products/pro/tracking-and-tasks/processes/) launch, with [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) data filled in automatically. There are two approaches: 1. **Public kick-off form link** - share your template's public kick-off URL so anyone can fill it out and launch a process as a guest. 2. **Magic link with pre-filled fields** - build a URL that pre-fills kick-off form fields for logged-in Tallyfy users, using the `ko_fields` parameter. ### Approach 1 - public kick-off form link This is the simplest method. Tallyfy generates a public URL for your template's [kick-off form](/products/pro/launching/triggers/kick-off-forms/). Anyone with the link can submit the form and launch a process. You don't need a Tallyfy login. When someone visits the link, Tallyfy asks for their email, then shows the kick-off form. On submission, the process launches automatically. ### Approach 2 - magic link with pre-filled fields For logged-in users, you can build a launch URL that pre-fills kick-off form values using the `ko_fields` query parameter. The `ko_fields` value is a JSON-encoded array where each element maps a field alias to its value. #### Example URL If your template has kick-off fields with aliases `customer_name` and `customer_email`: ```text https://go.tallyfy.com/#/org/{orgId}/process/{templateId}/create?ko_fields=[{"customer_name":"John Doe"},{"customer_email":"john@example.com"}]&launchprocess=true ``` :::note The `ko_fields` approach won't work unless you're logged into Tallyfy. For anonymous or guest access, use the public kick-off form link instead. ::: - **[Launch another process when a task completes](https://tallyfy.com/products/pro/launching/launch-process-when-task-is-completed/)**: Configure any task in a template to automatically launch a new process from a different template when it completes. You can also inject those tasks directly into the current process instead of creating a separate one. You can configure any [task](/products/pro/tracking-and-tasks/tasks/) in a Tallyfy [template](/products/pro/documenting/templates/) to automatically launch a new [process](/products/pro/tracking-and-tasks/processes/) from a different template when that task completes. This is useful for multi-phase workflows, customer journeys, and team hand-offs. ## When to use this * **Multi-phase projects** - finishing Phase 1 automatically starts Phase 2. * **Customer journeys** - completing "Sales" launches "Onboarding". * **Branching workflows** - an "Initial Review" task launches either "Approved Project" or "Further Review". * **Team hand-offs** - a Sales task triggers a process for Operations. ## How to set it up ![Launch process when task completed setting in the Advanced tab](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-launch-process-when-task-completed.png) ## Inject tasks instead of launching a new process Instead of launching a separate process, you can inject the target template's tasks directly into the current running process. All injected steps appear after the trigger task, keeping everything in one place. :::note[What "inject tasks" does] Injecting adds all steps from the target template into the current process instance, right after the trigger task. Everything stays in the same process - just with added steps. You can't inject from the same template twice. ::: ## Which templates can be launched or injected? The dropdown only shows templates that: * Are active (not archived or deleted). * Have **no** required [kick-off form fields](/products/pro/launching/triggers/kick-off-forms/) - since there's no user present to fill them in during automatic launch. * Are of type Procedure (with steps) or Form (with kick-off fields only) - not Document type. :::warning[Can't find your template?] If a template isn't listed, check that it's active, has no required kick-off fields, and isn't a Document-type template. ::: ## Naming the launched process You can control the name of the automatically launched process: 1. **Default name** - format is "Mon dd, h:mma - Template Name" (e.g. "Feb 26, 3:45pm - Client Onboarding"). 2. **Custom name** - use text plus [variables](/products/pro/documenting/templates/variables/) from the trigger process. Available variables include DATE, TEMPLATE_NAME, and text-type kick-off form fields. ![Custom naming options for an automatically launched process](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-custom-naming-process.png) ## Limitations * **Naming variables** - only DATE, TEMPLATE_NAME, and text-type kick-off form fields from the trigger process are available for custom naming. * **Passing data** - there's no built-in way to pass data from the trigger process to the launched process (other than via the name). For complex data transfer, use the Tallyfy [API](/products/pro/integrations/open-api/) or [webhooks](/products/pro/integrations/webhooks/) with [middleware](/products/pro/integrations/middleware/). * **Referencing data** - you can't reference data between original and injected tasks when using injection. * **Duplicate prevention** - if a process was already launched from a specific task, it won't launch again. Tallyfy adds a comment explaining this. ## Tracking the connection Tallyfy automatically links trigger and launched processes: 1. The trigger task and launched process are tracked in a relationship table - so you can trace which task launched which process. 2. The Tallyfy Bot adds a comment to the trigger task with a link to the newly launched process. ![Tallyfy Bot comment linking to the launched process](https://screenshots.tallyfy.com/tallyfy/pro/desktop-light-show-bot-comment.png) - **[Troubleshooting permissions](https://tallyfy.com/products/pro/launching/troubleshooting-launch-permissions/)**: Most process launch problems come from missing Standard member permissions or draft templates. Fix them by granting launch access on the Permissions tab, checking launcher assignment settings, and making sure Magic Links include required kick-off values. ## How to fix common process launch problems Standard members need explicit launch permission to start processes. Administrators and template owners can always launch. Here's how to fix the most common issues. ### Why can't a Standard member launch a process? **Problem**: A Standard member sees a template but gets "Permission denied: cannot launch process from this template." when trying to launch it. **Cause**: Standard members don't automatically have launch permission. Administrators and template owners bypass this check, but everyone else needs explicit `process_launch` permission. **Solution**: 1. Have an Administrator edit the template 2. Go to the **Permissions** tab 3. Enable launch permission for the specific Standard member or "All Members" 4. Save the template :::note You can't launch a draft template. If dual versioning's enabled, the template must be in a published state. ::: ### Why is the launcher being added to unassigned steps? **Problem**: When a process is launched, the launcher appears as an assignee on steps that have no one assigned. **Cause**: The "Assign launcher automatically" setting (`assign_run_starter`) is enabled on those steps. This only applies to steps with no assignees at all - no users, no groups, and no guests. Steps that already have group or member assignments aren't affected. **Solution**: 1. Edit the template 2. For each affected step, open the **Advanced** tab 3. Turn OFF "Assign launcher automatically" 4. Save the template ### Why do Magic Links fail with kick-off forms? **Problem**: A Magic Link doesn't launch the process when the template has required kick-off form fields. **Cause**: Magic Links can pass kick-off field values through the `ko_fields` URL parameter. If required fields aren't included or are empty, Tallyfy blocks the launch and shows the form instead. **Solutions**: 1. **Pass all required values** in the Magic Link's `ko_fields` parameter 2. **Make fields optional** if they don't need to be required 3. **Use public kick-off forms** for external users who need to fill out fields manually 4. **Use middleware** like Power Automate or Zapier to supply all required values programmatically ### Why can't I map dropdown fields in Power Automate? **Problem**: Dropdown field values from Tallyfy don't map correctly to other systems. **Cause**: Tallyfy dropdown fields return JSON objects with three properties (`id`, `text`, `value`) - not plain text strings. **Solution**: 1. Add a **Parse JSON** action after getting Tallyfy data 2. Access the specific property you need: - Display text: `body('Parse_JSON')?['fieldName']?['text']` - 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 fix permission errors in API integrations? **Problem**: API calls to launch processes return permission errors even with valid credentials. **Cause**: The authenticated API user must have `process_launch` permission for the specific template. Admin users and template owners are exempt. **Solutions**: 1. **Use Administrator credentials** for full launch access across all templates 2. **Grant launch permission** to the specific user if they're a Standard member 3. **Verify template restrictions** - the template might be limited to specific members only 4. **Test manually first** - try launching with the same user account in Tallyfy's UI to confirm permissions ### Checklist for avoiding launch issues | Area | What to check | |------|--------------| | Permissions | Set launch permissions when creating templates. Test with Standard member accounts before rollout. | | Assignments | Decide whether "Assign launcher automatically" should be on or off for each step. It only affects fully unassigned steps. | | Magic Links | Include all required kick-off field values in `ko_fields`. Test with sample data first. | | API setup | Confirm the API user has launch permission. Use Parse JSON for dropdown fields in Power Automate. | | Draft state | Publish the template before trying to launch. You can't launch draft templates. | - **[Triggers](https://tallyfy.com/products/pro/launching/triggers/)**: Tallyfy offers seven ways to start a process, from manual clicks and form submissions to API calls, emails, magic links, recurring schedules, and task completion chains. Some triggers can pre-fill kick-off form data to cut manual entry. ## Process launch triggers Triggers control how processes start in Tallyfy. Some are manual (a person clicks a button), others are automatic - fired by an event, a schedule, or another system. ### What you need * A Tallyfy account with permission to launch processes * At least one template ready to launch ### Available trigger methods * **Manual launch** - Click **Launch** on any template inside Tallyfy. * **API trigger** - Another system calls the Tallyfy API (`POST /organizations/{org}/runs`) to start a process programmatically. * **Email trigger** - Send an email to a template-specific Tallyfy address. The email subject becomes the process name. * **Magic links** - A special URL launches a process when clicked. You can embed these links in emails or websites and pre-fill data via URL parameters. * **Recurring schedule** - Tallyfy's built-in scheduler launches processes automatically on hourly, daily, weekly, monthly, or yearly intervals. * **Task completion trigger** - Completing a specific task in one process auto-launches another process, creating a chain. * **Kick-off form** - Submitting a form (public or internal) launches the process and fills in kick-off fields from the submission. ## Process trigger flow All seven methods lead to the same result - a running process. [Diagram removed for brevity] ### Sending data when launching Some triggers can pre-fill kick-off form fields automatically: | Trigger | How data is sent | |---------|-----------------| | API trigger | Include a `prerun` object in the API request body | | Magic links | Append data as URL query parameters | | Kick-off forms | Form field values map directly to kick-off fields | This cuts manual entry and reduces errors. ### Picking the right trigger Ask yourself: - What event should start the process - a person, another system, or a schedule? - Do you need data pre-filled automatically? - How technical is your team? - How often will the process run? You'll find setup details for each trigger type in the articles below. ### Triggers - **[Launch via a kick-off form](https://tallyfy.com/products/pro/launching/triggers/kick-off-forms/)**: Kick-off forms collect information before a Tallyfy template launches and pass that data into later workflow steps. External users can submit public kick-off forms to automatically start internal processes with email verification and progress tracking. ## What are kick-off forms? Kick-off forms sit at the beginning of a Tallyfy template and collect information before the main workflow starts. They work for both internal team members and external people - customers, partners, or vendors can submit a public kick-off form to launch a process automatically. Unlike standalone forms, kick-off form data flows directly into the process steps that follow. ### Creating a kick-off form ![Adding fields to a kick-off form in the template editor](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-how-to-add-kickoff-forms.png) ### Available field types | Field type | Use for | |-----------|---------| | Short Text | Names, IDs, brief responses | | Long Text | Descriptions, detailed explanations | | Dropdown | Pick one from a predefined list | | Multi-select | Pick multiple from a list | | Radio Buttons | Pick exactly one option | | Date | Scheduling, deadlines | | Email | Email addresses | | File Upload | Documents, images, attachments | | Table | Structured tabular data | | Assignee selector | Pick people to assign within the process | Mark fields as **Required** only if the process can't start without that data. Required fields prevent automatic launching via email triggers or some API calls that don't supply the field values. ### Completing kick-off forms ![Launching a process by filling out a kick-off form](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-launch-kickoff-form.png) ### Viewing kick-off form answers Anyone on the process can see submitted kick-off data: ![Viewing kick-off form answers on a task Info tab](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-show-kickoff-on-task.png) :::note[Filling forms automatically] You can pre-fill kick-off forms using data from other systems via [web form links](/products/pro/launching/how-to-launch-a-tallyfy-process-from-a-webform/) or middleware. ::: ### Public kick-off forms Share a kick-off form publicly so anyone - even without a Tallyfy account - can submit it to start a process. **Why use public forms:** - **Instant workflow launch** - no delay between submission and process start - **Submitter tracking** - the person who submits gets a unique link to track progress (after email verification) - **Spam prevention** - email verification filters out fake submissions - **Branding** - public forms display your organization's logo - **Self-service assignment** - mark an Assignee Picker field as "Default to guest" and the submitter is auto-assigned, no manual hand-off needed #### Deactivated members and public forms Tallyfy uses the `kickoff_sharing_user_id` to authenticate public form submissions. When that member gets deactivated, Tallyfy automatically reassigns the public form to the template owner. If the template owner is also inactive, the public link won't work. Check public form assignments before deactivating members. (See [Removing Members](/products/pro/documenting/members/how-can-i-remove-a-member-from-my-tallyfy-organization/).) :::note[Pre-fill kick-off form fields via URL] You can pre-fill kick-off form fields using URL parameters - this works for both public and internal kick-off forms. Add `ko_fields` with JSON field values and `default_run_name` to pre-set the process name. See [magic links](/products/pro/launching/triggers/magic-links/) for the complete URL format and field type reference. ::: ### Making a kick-off form public ### How public form submission works ### Public forms vs. internal steps | | Public kick-off forms | Internal process steps | |---|---|---| | **Audience** | External users without Tallyfy accounts | Team members and assigned guests | | **Purpose** | Collect initial data to start a workflow | Execute tasks after the process starts | | **Access** | Public link via email, website, etc. | Tallyfy dashboard with login | | **Experience** | Simple form with your branding | Full task management with comments, attachments, tracking | | **Visibility** | Submitters track overall progress only | Full internal task details | :::tip[Example: purchase requisitions] A vendor submits a purchase order through your public form. This creates an internal approval workflow where your finance team reviews and processes the order - invisible to the vendor except for status updates. ::: ### Best practices #### Collect only what's needed upfront - Ask for data the launcher definitely has right now - Save detailed branching questions for later workflow steps - Keep the form short. Don't front-load complexity. :::tip[Equipment insurance example] Instead of "List all equipment details, specifications, and carrier requirements" on the kick-off form, ask "Equipment or facilities?" and "Client ID?" Then use [automations](/products/pro/documenting/templates/automations/) to reveal detailed collection steps based on those answers. ::: #### Form design tips - Use clear field names - skip jargon - Arrange fields in logical order - Mark fields required only when truly necessary - Add help text for anything that needs explanation - Test the form before sharing it widely #### Common mistakes - **Front-loading questionnaires** - asking for info that isn't available yet - **Branching in kick-off forms** - conditional logic belongs in workflow steps, not the initial form - **Over-requiring fields** - making fields mandatory when launchers might not have that data - **Ignoring user context** - different users have different information at launch time - **[Launch via API](https://tallyfy.com/products/pro/launching/triggers/via-api/)**: Tallyfy's REST API lets you launch processes by sending a POST request with a template ID and optional pre-filled data. External events like CRM deal closures or form submissions can automatically kick off tracked workflows with custom names, assignments, and deadlines. ## Start a Tallyfy process automatically from another system You can have another system start a Tallyfy process for you, with nobody clicking a button. When a deal closes in your CRM, a customer onboarding process can kick off on its own. When someone submits a form, the matching workflow starts and tracks itself. Your developer sets this up once using Tallyfy's API[^1], and from then on it just runs. This is for teams that want their tools to talk to each other. If you'd rather start a process by hand, by email, or from a public form, see the other [trigger options](/products/pro/launching/triggers/). ### What another system can set when it starts a process - Pre-fill your [kick-off form fields](/products/pro/launching/triggers/kick-off-forms/) with data it already has, like the customer's name, the deal value, or a start date - Give the process a clear name so it's easy to find later - Assign the right people, groups, and roles to each step - Set deadlines - Tag the process and drop it in the right folder ### Common ways people use this - **CRM**: start onboarding the moment a deal closes - **Document management**: kick off an approval when a file is uploaded - **Sensors and devices (IoT)**: launch an inspection when a sensor raises an alert - **External forms**: create a process from a form filled out on another site - **Databases**: start a workflow when a record changes ## For developers *(Skip this unless you're setting up the technical side.)* To launch a process, send a `POST` request to Tallyfy's REST API. You trigger it from your own code, which runs when something happens in another system: a CRM deal closing, a form submission, a sensor alert, and so on. ### What you'll need - A Tallyfy account with API access - An OAuth Bearer token for authentication - The `checklist_id` (template ID) you want to launch - Familiarity with REST APIs and JSON ### How to launch a process 1. **Get your access token** - set up OAuth in Tallyfy and store your Bearer token securely. 2. **Find the template ID and the field IDs** - grab the `checklist_id` from the URL when you're viewing your [template](/products/pro/documenting/templates/), then call `GET /organizations/{org_id}/checklists/{checklist_id}` and note the `id` of every [kick-off form field](/products/pro/launching/triggers/kick-off-forms/) you want to pre-fill. They're listed in the response's `prerun` array. 3. **Send the POST request** - call `POST /organizations/{org_id}/runs` with a JSON body containing `checklist_id` and process details. 4. **Handle the response** - you'll get a `201` response with the new process data, including its ID. Add error handling for failures. Pass extra data through the `prerun` object to pre-fill kick-off form fields. You can also set the process name, per-step assignments (users, groups, and roles), and deadlines in the same request. Every key inside `prerun` is a kick-off field's timeline ID, a 32-character hex string. That's the `id` on each entry of the `prerun` array you got back in step 2. Don't use the `alias` sitting next to it in that same response, and don't use the field's label. Keys like `customer_name` never match anything. ### Sample API request ```json POST /organizations/{org_id}/runs HTTP/1.1 Host: go.tallyfy.com Authorization: Bearer YOUR_ACCESS_TOKEN Content-Type: application/json X-Tallyfy-Client: APIClient { "checklist_id": "f7e6d5c4b3a2918070615243342516f0", "name": "Customer Onboarding - Acme Corporation", "prerun": { "a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6": "Acme Corporation", "3c9d1e7fa4b820516d8e2f7a9c0b4d15": "15000", "9f2b7c1e4a6d8035b1c7e9d2f4a6b801": "2024-01-15T00:00:00.000Z" } } ``` Those three keys are the timeline IDs of the "Customer name", "Contract value", and "Start date" kick-off fields. :::caution[The wrong key fails silently] Tallyfy matches every `prerun` key against the kick-off fields' timeline IDs. A key that matches nothing gets dropped without an error, so the request still returns `201 Created` and the process starts with that field empty. If a pre-filled value goes missing, check your keys first. ::: Each `prerun` value's shape depends on the field type. The per-type list lives on [Launch process](/products/pro/integrations/open-api/code-samples/processes/launch-process/). [^1]: A way for other software to talk to Tallyfy directly, sending and receiving data without anyone using the screen. - **[Email triggers](https://tallyfy.com/products/pro/launching/triggers/via-email/)**: Launch a Tallyfy process by sending an email to a template's unique trigger address. Tallyfy verifies the sender is an active member and uses the email subject line as the process name. Send an email to a template's unique address to start a process without logging into Tallyfy. This works well for mobile users or when you're working from external systems. ## Prerequisites - Permission to edit templates - No **required** kick-off form fields in the template (optional fields are fine) - Sender's email must belong to an active member in your organization :::warning[Can't use with required kick-off fields] Email triggers **don't work** if the template has any kick-off form fields marked as **Required**. You'll get a failure notification email. Only use templates with optional (or no) kick-off fields for email launching. ::: ## Setting up email triggers Each template gets its own unique email address. ## What happens when an email arrives 1. Tallyfy checks if the sender is an active member in your organization. Non-members get a rejection email. 2. If verified, Tallyfy launches a new process from the linked template. 3. The email **Subject** becomes the process name. 4. If you've set up email capture fields (see below), the body and attachments fill in automatically. 5. Assignees on the first task(s) get notified. ## How does the email trigger process work? This diagram shows the full validation flow and possible outcomes. [Diagram removed for brevity] ### Capturing email content Tallyfy can save the email body and attachments into kick-off form fields. When you open the **Via inbound email** trigger panel, Tallyfy offers to create these fields for you with a **Create it now** link: | Field Label | What it captures | Field type | |-------------------------|-----------------------------------|------------------------| | `Inbound Email Trigger - Email Body` | The full text of the email body | Long Text Area | | `Inbound Email Trigger - Email Attachments` | Files attached to the email | File Upload | These fields are optional. Without them, the process still launches - you just won't capture the email content. ![Creating email capture fields for inbound email trigger](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-create-email-fields.png) ### Email address format The trigger email address follows this pattern: ```text bot+[TemplateID]-launch@tallyfy.com ``` `[TemplateID]` is your template's unique ID. You don't need to construct this yourself - Tallyfy shows the full address in the trigger panel. ### Example uses - **Site visit reports** - Technicians email after visits (Subject: Site Visit - Client X; Body: details; Attachments: photos) - **Support escalation** - Forward a customer email to the trigger address to start a complaint process :::caution[Consider structured forms instead] Email triggers work, but emails are unstructured - people write whatever they want, in any format. This creates data quality issues. **Better approach**: Use [kick-off forms](/products/pro/launching/triggers/kick-off-forms/) instead. Structured forms give you consistent data formats, required fields, and validation before the process starts. Use email triggers as a fallback, not your primary launch method. ::: ### Smart email forwarding with keywords You can launch Tallyfy processes from regular email conversations using a keyword and an email filter rule. 1. Pick a unique keyword like `TRIGGER-TALLYFY` 2. Set up an email rule in Gmail, Outlook, or your mail system that: - Watches for emails containing your keyword - Auto-forwards matches to the Tallyfy template address 3. The process launches when Tallyfy receives the forwarded email Use different keywords for different templates (e.g., `TRIGGER-ONBOARDING`, `TRIGGER-COMPLAINT`). **Gmail example:** 1. Go to **Settings** > **Filters and Blocked Addresses** 2. Create filter: "Has the words: TRIGGER-TALLYFY" 3. Action: Forward to `bot+[TemplateID]-launch@tallyfy.com` ### Security notes - Only active Tallyfy members in your organization can trigger launches. Tallyfy rejects emails from outsiders - Each template has its own unique trigger email address - Write clear subjects - they become the process name ### Adding comments via email replies You can add comments to existing tasks by replying to Tallyfy task notification emails. The reply-to address format is `bot+[TaskID]-comment-task@tallyfy.com`. ### Best practices - Keep a shared list of trigger email addresses for your team - Agree on standard subject line formats for easier tracking - Test the trigger from each email client your team uses - **[Launch via a magic link](https://tallyfy.com/products/pro/launching/triggers/magic-links/)**: Magic links in Tallyfy are special URLs that let logged-in users trigger actions like launching processes or completing tasks simply by clicking a link and these can be embedded in emails or intranet pages with pre-filled data using URL parameters and JSON-encoded field values. Magic links are URLs that trigger Tallyfy actions automatically when a logged-in user clicks them. Here's what you can create links to: - Launch a process from a template (and pre-fill kick-off data) - Create a one-off task - Complete or re-open a specific task - Add a comment to a task - Change a task's deadline - Update a form field value on a task :::note[Works for both internal users and public forms] Magic link URL parameters (`ko_fields`, `default_run_name`) work on both internal kick-off forms (for logged-in users) and [public kick-off forms](/products/pro/launching/triggers/kick-off-forms/) (for external guests). This means you can embed pre-filled public form links on your website. ::: :::warning[Required kick-off fields] Magic links can't bypass required kick-off form fields. If your template has required fields, the magic link won't work because it tries to start the process without showing the form. Workarounds: - Make kick-off fields optional if appropriate - Use API calls that can supply all required field data - Use [public kick-off forms](/products/pro/launching/triggers/kick-off-forms/) for manual entry - Use middleware platforms that programmatically supply required values ::: ## Access the magic link generator 1. Go to **Settings** > **Integrations**. 2. Find the **Magic Links** card and click **Get a Magic Link**. ## Available actions | Action | What it does | |--------|-------------| | Create one-off task | Creates a standalone task | | Launch a process | Starts a new process from a template | | Complete a task | Completes a specific task | | Reopen a task | Re-opens a completed task | | Write comment to a task | Adds a comment to a specific task | | Edit task deadline | Updates the due date of a task | | Update form field value | Changes a form field value on a task | ## Create a magic link to launch a process 1. Click **Get a Magic Link** in the Magic Links card. 2. Choose **Launch a process**. 3. Select the template you want the link to launch. 4. Set the default process name (you can use variables). 5. Copy the generated URL. 6. Optionally add more parameters manually to pre-fill [kick-off fields](/products/pro/launching/triggers/kick-off-forms/). ## Create a magic link for one-off tasks 1. Click **Get a Magic Link**. 2. Choose **Create a one-off task**. 3. Set the default task name. 4. Copy the generated URL. ## Magic link URL structure A link to launch a process and pre-fill data follows this pattern: ```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 (max 550 characters). - `ko_fields` contains kick-off field names and values to pre-fill as JSON. - All values must be [URL encoded](https://www.w3schools.com/tags/ref_urlencode.ASP) (spaces become `+` or `%20`). Don't forget this step. - The `ko_fields` JSON - `[{"field-name":"field-value"}]` - must also be URL-encoded. :::note[This isn't the API format] `ko_fields` belongs to magic links only. It's an array of single-key objects, and the keys are kick-off field names. Launching through the [REST API](/products/pro/launching/triggers/via-api/) is a different surface with different rules: there you send a `prerun` **object** whose keys are the fields' 32-character timeline IDs, not their names. The two formats aren't interchangeable, so don't copy `ko_fields` pairs into an API payload. ::: :::note[Auto-naming] If your template has auto-naming enabled, Tallyfy generates the process name from kick-off field values using the `default_process_name_format` set on the template. The auto-generated name can't exceed 550 characters. You'll still need to provide all required kick-off fields in `ko_fields`, or the launch will fail. ::: ## Field value syntax Use this format for `ko_fields` values (before URL-encoding): | Field type | Example JSON value | |------------|-------------------| | Short/Long text | `"Your Text Value"` | | Dropdown | `{"id":ID,"text":"Selected Label","value":null,"required":true}` (get ID from template editor) | | Checkbox | `[{"id":ID,"text":"Checked Label","value":null,"required":false,"selected":true}]` | | Radio button | `"Selected Radio Value"` | | Date/Time | `"YYYY-MM-DDTHH:mm:ss.SSSZ"` (UTC format) | ## Other action examples Replace `[YourOrgID]` and `[TaskID]` with your actual values. All task-based actions use the `/:org_id/magic` URL path. - **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-DDTHH:mm:ss.SSSZ` - **Update form field:** `...?action=updateFormFieldValue&task_id=[TaskID]&form_fields={"fieldId123":"New+Value"}` ## Pre-fill public kick-off forms You can pre-fill fields on public kick-off forms using the same `ko_fields` and `default_run_name` parameters. The public form URL follows this pattern: ```text https://go.tallyfy.com/[YourOrgID]/public/kickoff/[TemplateAlias]?ko_fields=[JSON]&default_run_name=[Name] ``` This is useful when you want to embed application links on your website with specific values pre-selected. For example, you'd pre-fill a property name based on which listing page the visitor clicked from. **Field value format reference** (before URL-encoding): | Field type | JSON format in `ko_fields` | Example | |------------|---------------------------|---------| | Short text | `"fieldAlias": "value"` | `"first-name": "John"` | | Long text / Textarea | `"fieldAlias": "value"` | `"notes": "Line 1"` | | Dropdown | `"fieldAlias": {"id": N, "text": "Label"}` | `"property-name": {"id": 4, "text": "16 Laurel"}` | | Radio button | `"fieldAlias": "Selected Label"` | `"housing-type": "BPDA"` | | Checkbox / Multiselect | `"fieldAlias": [{"id": N, "text": "Label", "selected": true}]` | `"unit-sizes": [{"id": 1, "text": "Studio", "selected": true}]` | | Date | `"fieldAlias": "YYYY-MM-DDTHH:mm:ss.SSSZ"` | `"app-date": "2026-03-05T00:00:00.000Z"` | | Email | `"fieldAlias": "email@example.com"` | `"contact": "john@example.com"` | **Practical example** - embedding on a property listing website: ```html Request Application ``` When a visitor clicks this link, they enter their email for verification, then see the kick-off form with the property name already selected. The same `ko_fields` JSON format works for both logged-in and public kick-off forms. ## Where to use magic links - Buttons or links in emails (e.g., "Click here to approve") - Links on your company intranet - Buttons generated by other tools like your CRM - QR codes for mobile-friendly workflow triggers - **[Launch via middleware](https://tallyfy.com/products/pro/launching/triggers/via-middleware/)**: Middleware platforms like Zapier and Make.com let you automatically launch Tallyfy processes from events in other apps, like form submissions or new CRM records. They watch for triggers and pass mapped data into Tallyfy kick-off forms without custom coding. ## How can I launch Tallyfy processes using middleware? ### What you'll need * A Tallyfy account with launch permission (Admin, template owner, or granted PROCESS_LAUNCH access) * An account on a middleware platform (Make.com, Power Automate, or Zapier) * A published Tallyfy template ready to launch * Access to the external system that'll trigger launches (CRM, form tool, database, etc.) ### How middleware launching works Middleware tools bridge Tallyfy and your other apps. They watch for an event in another application (the "trigger"), then automatically call the Tallyfy API to start a process - passing data along. No custom coding required. ### The 5-step flow 1. **Connect** - Link your middleware tool to Tallyfy and the trigger app using API credentials. 2. **Trigger** - Pick the event that should start things (e.g., "New contact in HubSpot", "Form submitted in Typeform"). 3. **Map data** - Map fields from the trigger app to your Tallyfy kick-off form fields (the `prerun` data). 4. **Launch action** - Add a "Launch Process" action pointing to your Tallyfy template's `checklist_id`. 5. **Run** - When the trigger fires, middleware auto-launches the Tallyfy process with mapped data. ### Visualizing the middleware integration flow This diagram shows how external applications trigger Tallyfy processes through middleware platforms. [Diagram removed for brevity] **What to notice:** - Middleware watches for events and translates between systems (steps 2-4) - Data mapping happens within the middleware before reaching Tallyfy - Once configured, everything runs automatically ### What can middleware do with Tallyfy? * Launch Tallyfy processes from events in other tools (new CRM deal, calendar event, database update) * Pass external data straight into Tallyfy kick-off form fields * Transform data formats between systems when needed * Add conditional logic - only launch if certain criteria are met in the trigger app ### Connecting online forms When someone submits a form, middleware grabs the answers and launches a Tallyfy process automatically. It's one of the most common use cases. | Form Tool | Connection Type | Data Sent | |-------------------|-----------------------|-------------------| | Google Forms | Built-in connector | All form answers | | Microsoft Forms | Built-in connector | All form answers | | Typeform | Webhook | All form answers | | Wufoo | Webhook | All form answers | | Cognito Forms | Webhook | All form answers | ### Choosing a middleware platform * **Make.com (Recommended)** - Flexible, great for complex data mapping. * **Microsoft Power Automate (Recommended)** - Best if you're already on Microsoft 365. * **Zapier** - Simple setup, wide app support. * **Pabbly** - Affordable, solid basics. * **Workato / Tray.io** - Enterprise-grade, for complex needs. When deciding, think about: connection complexity, budget, which apps you already use, how much data transformation you need, and your team's technical comfort. ### Setting up middleware integration 1. **Plan** - Decide which event/app should trigger which Tallyfy template launch. 2. **Choose** - Pick your middleware tool. 3. **Build** - Create the workflow: set a trigger, add a Tallyfy "Launch Process" action, map data fields. 4. **Test** - Verify processes launch correctly with the right data. 5. **Activate** - Turn on your workflow and monitor it. See the [middleware integration guide](/products/pro/integrations/middleware/) for platform-specific setup details. - **[Launch via a schedule](https://tallyfy.com/products/pro/launching/triggers/via-recurring-schedule/)**: Auto-launch Tallyfy processes on recurring schedules using middleware platforms like Zapier or Make.com. You can also write custom scripts that call the Tallyfy API on a cron schedule for daily checklists, monthly audits, and more. ## How do I launch processes on a recurring schedule? You can auto-launch [processes](/products/pro/tracking-and-tasks/processes/) on a repeating schedule - daily, weekly, monthly, or at any interval you need. The easiest way is through a [middleware](/products/pro/integrations/middleware/) platform like Zapier, Make.com, or Power Automate. You can also write a custom script that calls the Tallyfy API on a cron schedule. ### What you'll need - A Tallyfy account with process launch permission (Admin, template owner, or granted launch access) - A published [template](/products/pro/documenting/templates/) ready to launch - A middleware account (Zapier, Make.com, Power Automate) or a server where you can run scheduled scripts ### Option 1 - middleware platforms It's the fastest approach. No coding required. **Example - daily equipment check:** ``` Trigger: Schedule (Every day at 8:00 AM) Action: Launch Tallyfy process Template: Equipment Safety Check Process name: Equipment Check - {date} ``` ### Option 2 - API with a cron job Write a server-side script and schedule it with cron (Linux/Mac) or Task Scheduler (Windows). **Example - Node.js script launching every Monday at 9 AM:** ```javascript const cron = require('node-cron'); const axios = require('axios'); cron.schedule('0 9 * * 1', async () => { try { await axios.post('https://go.tallyfy.com/api/organizations/YOUR_ORG_ID/runs', { checklist_id: 'your-template-timeline-id', name: `Weekly Report - ${new Date().toLocaleDateString()}` }, { headers: { 'Authorization': 'Bearer YOUR_API_TOKEN', 'X-Tallyfy-Client': 'APIClient', 'Content-Type': 'application/json' } }); console.log('Process launched'); } catch (error) { console.error('Launch failed:', error); } }); ``` ### Option 3 - trigger from existing systems If you're already using an ERP, HRIS, or another system with scheduling, you can have it call the Tallyfy API directly or go through middleware. ### Common use cases | Process type | Frequency | Example | |---|---|---| | Compliance audits | Monthly | Launch inspection process on the 1st of each month | | Financial reporting | Weekly | Launch expense approval every Friday at 4 PM | | Team updates | Daily | Launch standup checklist each morning at 9 AM | | Maintenance checks | Quarterly | Launch facility inspection on the first day of each quarter | :::note[Process naming] For scheduled [processes](/products/pro/tracking-and-tasks/processes/), include the date in the name for easy tracking. Example: "Monthly Compliance Check - January 2026" ::: ### Integrations - **[Extract tasks from meetings](https://tallyfy.com/products/pro/integrations/extract-tasks-from-meetings/)**: Tallyfy is building a feature to transcribe meetings and extract action items as draft tasks with assignee mapping via SSO. Until it launches, you can build your own pipeline using Tallyfy's API with tools like OpenAI Whisper and GPT-4. ## Converting meeting recordings into tasks ## The meeting productivity problem Your team finishes an hour-long meeting. Six people agreed to do twelve things. By next week, three get done, five are forgotten, and four were misunderstood. Meetings generate lots of work, but without tracking, action items disappear. You've seen the cycle - repeated meetings where people ask "wait, who was supposed to do that?" because nobody captured tasks from the last one. ## How Tallyfy will solve this We're building an integration that connects your meeting platform (Zoom, Teams, Google Meet) to Tallyfy's task system. Record your meeting as usual - Tallyfy handles the rest. The system will transcribe your meeting using AI that works with multiple languages, then analyze the conversation to identify who committed to what and when. ### Identity recognition "John, can you send the proposal to the client by Friday?" Simple for humans. Surprisingly hard for AI. The planned system will identify both the task creator (the person asking) and the assignee (John) using SSO integration. When your team logs into both the meeting platform and Tallyfy with the same SSO provider, voices get matched to user profiles automatically. John gets assigned the task. The requester becomes the creator. If someone joins as a guest or SSO isn't configured, the system will create placeholder assignments you can map to real users during review. ### Rich task context, not just titles A task titled "Send proposal" tells you nothing. The system will capture 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 a task 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 will include the actual quote from the meeting and the AI's reasoning for flagging it as a task. ### Conversation thread tracking Conversations aren't linear. Someone proposes an idea at minute 5. It gets modified at minute 15. By minute 30, the team decides something different. Naive extraction would create three conflicting tasks. The AI will track conversation threads throughout the meeting and understand when action items evolve, get canceled, or change - delivering only the final agreed-upon version of each task. ## The planned Draft state AI isn't perfect. That's why we plan to introduce a new task state: Draft. [Diagram removed for brevity] Draft tasks would work like a moderation queue - all extracted tasks appear grouped together for review. You'd edit assignments, adjust deadlines, delete irrelevant items, and convert good ones to active tasks. This human-in-the-loop approach means AI handles extraction and organization while you provide the final quality check. ## Technical challenges ### Accuracy at scale Current systems face several hurdles: - **Background noise and cross-talk** reduces transcription accuracy - **Technical jargon** causes misinterpretation - **Multiple speakers at once** creates attribution errors - **Long meetings** exceed AI context windows ### The hallucination problem Language models sometimes generate tasks that were never discussed - invented from context clues rather than explicit conversation. The planned approach uses multiple validation layers: requiring explicit transcript evidence for every task, confidence scoring with warning flags on low-confidence items, and human review before tasks go live. ### Meeting evolution patterns Conversations follow common patterns that affect extraction: - **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 ## Planned platform support ### Phase 1 - major video conferencing - Zoom, Microsoft Teams, Google Meet, Cisco Webex ### Phase 2 - specialized platforms - Slack Huddles, Discord, GoToMeeting, BlueJeans ### Phase 3 - recording tools - Otter.ai, Fireflies.ai, Sembly AI, Jamie ### Phase 4 - async collaboration - Loom, Vidyard, BombBomb, Soapbox ## Current workaround - build it yourself You can build your own meeting-to-tasks pipeline today using Tallyfy's API. This requires technical expertise and ongoing maintenance. ### What you'll need You're responsible for: - Capturing and storing meeting recordings - Transcribing audio to text (using OpenAI Whisper, Google Speech-to-Text, etc.) - Extracting action items from transcripts (using GPT-4 or Claude) - Mapping speakers to Tallyfy users - Creating tasks via Tallyfy's API - Handling errors and retries ### Pipeline architecture ### Extraction patterns that work **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 ```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**: Use 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): content = f"{meeting_id}:{task['assignee']}:{task['description']}" return hashlib.md5(content.encode()).hexdigest() if not task_exists(fingerprint): create_task(task) ``` **Privacy and compliance**: - Store recordings in compliant storage (HIPAA/GDPR) - Redact sensitive information from transcripts - Control access to task creation - Maintain audit logs linking tasks to source recordings ### Testing your pipeline ```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 to measure pipeline 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 ## What's next When the official feature launches, you'll get: - Zero-configuration setup - Built-in transcription - Conversation thread tracking - The Draft state review workflow - Native integration with major platforms - Automatic user mapping via SSO - No coding or maintenance required The initial release will target Zoom, Teams, and Google Meet, with more platforms to follow. Want early access? Contact our support team to join the beta program. - **[Handling idempotency](https://tallyfy.com/products/pro/integrations/handling-idempotency-in-webhooks-and-api/)**: Idempotency ensures that duplicate webhook events or retried API requests from Tallyfy don't cause problems like double records or repeated emails. Handle retries safely with deduplication tables, unique event keys, and conditional updates. ## What is idempotency and why it matters Idempotency means your integration handles the same event twice without breaking anything. Like pressing an elevator button multiple times - the elevator still only comes once. This matters because Tallyfy [webhooks](/products/pro/integrations/webhooks/) can fire more than once for the same logical event. External systems might retry [API](/products/pro/integrations/open-api/) requests. Network issues happen. Without idempotency handling, you'll end up with duplicate database records, double-sent emails, or repeated charges. ## Common scenarios requiring idempotency ### Task reopened and recompleted Someone completes a [task](/products/pro/tracking-and-tasks/tasks/) in Tallyfy, then reopens it and completes it again. Your webhook fires both times - same task, different timestamps. 1. User completes the task 2. Your webhook receives the event 3. User reopens the task, then completes it again 4. Your webhook receives another event for the same task Without deduplication, this creates duplicate records, repeated emails, and double-processed payments. ### Template-level webhooks fire per task When you set a webhook URL on a [template](/products/pro/tracking-and-tasks/processes/), it fires on every task completion in any process launched from that template - not just once per process. A 10-task process means 10 webhook events. The same webhook URL also fires when the process is launched. ### External systems sending duplicates Your own systems can cause duplicates too - a helpdesk retries a failed request that actually succeeded, or a user double-clicks a button that fires multiple API calls. ## Implementing idempotency strategies ### Use unique identifiers from the payload Tallyfy webhook payloads include unique IDs you can use for deduplication. A task completion webhook contains a nested structure with task details: ```json { "this_task": { "id": "abc123", "title": "Review document", "alias": "review_doc", "status": "completed", "completed_at": "2024-01-15T10:30:00Z", "completed_by": { "email": "user@example.com" }, "captures": { ... } }, "process": { "id": "xyz789", "name": "Document Review", "status": "active" } } ``` Use the task `id` combined with `completed_at` as your deduplication key. Check this combination before processing, and skip if you've seen it before. ### Build an event deduplication table Track processed events in a dedicated table: ```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 from `task_id + event_type + timestamp` 2. Check if that ID exists in your table 3. If new, process it and store the ID 4. If it exists, log and skip ### Handle duplicates gracefully When duplicate API requests arrive, don't throw errors - work with them: 1. **Return success for duplicates** - If an external system tries to create a record that already exists, return a 200 OK with the existing record instead of an error. 2. **Use conditional updates** - Before updating [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) through the API, check the current value first. If it already matches, skip the update. 3. **Track request IDs on your side** - Have external systems include a unique ID with each call and cache results for 24 hours. When you see a repeated ID, return the cached response. ## Best practices for specific integrations ### Task completion webhooks Tasks can be reopened and recompleted. Decide your strategy up front: - **First completion only** - Ignore subsequent completions for the same task ID - **Track all completions** - Store each completion separately with its timestamp - **Latest wins** - Update your records each time, keeping only the most recent completion ### Managing template-level webhook volume A process with many tasks generates many webhooks. To handle the volume: 1. **Batch processing** - Collect events and process in chunks every few minutes instead of one at a time 2. **Use queues** - Push webhook events into a message queue so your system doesn't get overwhelmed 3. **Filter by task** - Check the payload's `this_task.alias` or `this_task.position` and only process the tasks you care about ### Preventing duplicate API calls to Tallyfy Before sending write requests to Tallyfy's API, check the current state first: - About to launch a process? Query whether one already exists for this trigger - Completing a task? Verify it isn't already completed - Updating a form field? Confirm the current value differs from what you're sending ## Example implementation patterns ### Pattern 1 - Webhook processor with deduplication ```javascript async function processWebhook(payload) { const task = payload.this_task; const eventKey = `${task.id}-completed-${task.completed_at}`; const existing = await db.query( 'SELECT * FROM processed_events WHERE event_id = ?', [eventKey] ); if (existing.length > 0) { console.log('Duplicate event, skipping:', eventKey); return { status: 'duplicate' }; } await handleEvent(payload); await db.query( 'INSERT INTO processed_events (event_id, processed_at) VALUES (?, NOW())', [eventKey] ); return { status: 'processed' }; } ``` ### Pattern 2 - API integration with retry safety ```javascript async function updateTaskField(taskId, fieldName, fieldValue, requestId) { const cachedResult = await cache.get(`request:${requestId}`); if (cachedResult) return cachedResult; const task = await tallyfyApi.getTask(taskId); if (task.fields[fieldName] === fieldValue) { const result = { status: 'unchanged' }; await cache.set(`request:${requestId}`, result, 86400); return result; } const updatedTask = await tallyfyApi.updateTask(taskId, { fields: { [fieldName]: fieldValue } }); const result = { status: 'updated', task: updatedTask }; await cache.set(`request:${requestId}`, result, 86400); return result; } ``` ## Testing your idempotency implementation 1. **Simulate duplicate webhooks** - Fire the same payload at your endpoint 3-4 times in a row and confirm only one record is created 2. **Test network retries** - Use Postman or curl to simulate timeouts and verify retries don't create duplicates 3. **Check data consistency** - After tests, verify no corrupted or duplicated data 4. **Monitor production logs** - Watch for duplicate patterns once live ## Troubleshooting common issues | Issue | Cause | Solution | |-------|-------|----------| | Duplicate records in database | No check before insert | Add unique constraints and check before inserting | | Missing webhook events | Treating duplicates as errors | Log duplicates but always return a 2xx response | | Inconsistent data state | Events processed out of order | Use timestamps for correct ordering | | Rate limits from retries | Not caching successful responses | Cache responses with an appropriate TTL | :::warning[Important] Always respond with a 2xx status code to Tallyfy webhook requests, even for duplicates. Returning an error code could cause issues with delivery tracking. A 200 response with a "duplicate" message in the body is the safest approach. ::: ## Next steps 1. Monitor logs for duplicate patterns - they'll reveal retry behaviors you didn't expect 2. Tune your deduplication window based on real-world data 3. For full audit trails, consider event sourcing 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 handles multilingual teams two ways: switching the interface language through account settings, or translating user-generated content like task descriptions and comments via a Microsoft Azure Translation API connection. ## 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, form answers If you're operating internationally, check out [global workplace language requirements](/products/pro/integrations/azure-translation/global-workplace-language-requirements/). Many countries require translating employee documentation (SOPs, policies, training materials) into local languages. ### Changing the UI language This setting changes what *you* see in Tallyfy's interface. - **What it changes**: Menus, buttons, and system messages - **How to change it**: 1. Click **Settings** (bottom left) 2. Go to **My Account** 3. Find the **Personalization** section and pick your language from the dropdown 4. Tallyfy updates instantly *Can't find your language? Contact Tallyfy support.* ### Translating content with Azure AI Microsoft Azure's translation service can automatically translate everything users type *within* Tallyfy. - **What it translates**: Process descriptions, task instructions, form answers, and comments - all user-generated content - **How it works**: You'll need an API key from Microsoft Azure AI Services - **Who sets it up**: Your Tallyfy administrator connects Tallyfy to your company's Azure account ## Setting up the Azure translation connection ### 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 full details. Here's the overview: 1. Get your API key and endpoint from Azure 2. Go to **Settings** > **Integrations** in Tallyfy 3. Find **Azure Translation Services** 4. Enter your Azure API key and endpoint 5. Save Done. A language selector appears at the top of Tallyfy for everyone. ## Using content translation Once Azure is connected: 1. Click the language selector icon in the top menu bar 2. Pick your language 3. Browse Tallyfy - all user-written text automatically appears in your chosen language 4. Translations happen in real-time as you move through tasks and processes ## Tips for better translations - **Write clearly** - short, simple sentences translate far better than complex ones - **Review important text** - have a native speaker double-check automatic translations for critical information - **Watch the jargon** - company-specific terms might come out wrong in translation - **Stay consistent** - using the same terms throughout helps the AI produce consistent translations ## Troubleshooting translation issues Nothing happening? Here's what to check: 1. Verify your Azure API key is correct in Tallyfy settings and still active in Azure 2. Confirm you've selected 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? Contact Tallyfy support - **[Authentication and SSO](https://tallyfy.com/products/pro/integrations/authentication/)**: Tallyfy offers free, self-serve SSO and SCIM on any paid plan with support for Microsoft Entra ID, Google Workspace, Okta, OneLogin, JumpCloud, and any SAML 2.0 provider. Org admins configure SSO themselves under Settings, verify a domain by DNS TXT, sync users with SCIM, and can enforce SSO-only login with an admin break-glass. ## Single Sign-On integration Tallyfy includes free Single Sign-On (SSO) on any paid plan, and you set it up yourself. An org admin configures the connection, tests it, and turns it on from **Settings > Organization > Security > SSO**. No support ticket needed. Your team then logs in with existing corporate credentials from Microsoft Entra ID, Google Workspace, Okta, OneLogin, JumpCloud, or any SAML 2.0 provider. Most admins finish in about 30 minutes. There's more than just login. You can verify your email domain by DNS so new users auto-join the right org, sync your whole directory with SCIM so people are added and removed automatically, and enforce SSO-only access that blocks email and password logins. Owners and admins always keep a password fallback, so a broken identity provider can't lock you out. :::note[Available on any paid plan] Self-serve SSO, domain verification, SCIM directory sync, and SSO-only enforcement are all included on any active paid Tallyfy plan. There's no separate add-on and no per-feature tier. If your org is on a free or expired plan, the Security pages prompt you to upgrade first. ::: ### Where to set it up Everything lives in one place. Sign in as an administrator, open **Settings > Organization > Security**, and you'll find tabs for **SSO**, **Domains**, **SCIM**, and the security **Activity** log. Each tab is covered in its own guide below. ### SSO benefits | Benefit | What it means | |---------|---------------| | **Security** | Apply your company's existing security rules and MFA (an extra login check beyond a password) to Tallyfy | | **One login** | Team members use their corporate username and password | | **Access control** | Manage Tallyfy permissions from your identity provider | | **Auto-provisioning** | New users get Tallyfy accounts on first SSO login (once your domain is verified) | | **Directory sync** | SCIM adds, updates, and deactivates users automatically from your IdP | | **Consistent policies** | Same password complexity and session rules across all systems | | **Less IT overhead** | No more Tallyfy-specific password resets | ### Set up SSO yourself The SSO wizard walks you through it in four steps. You don't need to write any XML by hand. 1. **Pick your identity provider.** Choose Okta, Microsoft Entra ID, Google Workspace, OneLogin, JumpCloud, generic SAML, or generic OIDC. Tallyfy shows you the exact SP values to copy into your IdP (the ACS URL and entity ID). 2. **Enter your IdP details.** Use one of the three methods below. 3. **Test the connection.** Tallyfy validates your metadata and certificate before it lets you go live, so you catch problems early instead of during a real login. 4. **Turn it on.** Once the test passes, enable the connection. Your team can sign in through SSO right away. Pick the per-IdP guide further down for screenshots and the exact field names in your provider. ### Three ways to connect your identity provider When you reach the "enter IdP details" step, Tallyfy gives you three ways to hand over your provider's SAML metadata. They all end up in the same place, so use whichever your IdP makes easiest. | Method | When to use it | What you paste | |--------|----------------|----------------| | **Metadata URL** | Your IdP publishes a metadata link (most do). The easiest option. | The URL. Tallyfy fetches and parses it for you. | | **XML paste** | Your IdP gives you a metadata file to download. | The full metadata XML, pasted into the box. | | **Manual entry** | You'd rather type the values, or your IdP doesn't export metadata. | The sign-in URL, issuer/entity ID, and signing certificate. | With the metadata URL method, Tallyfy can re-read your IdP's metadata later, which helps when your provider rotates its signing certificate. ### Verify your domain first Before SSO can auto-join new people or be enforced org-wide, you prove you own your email domain. You do this by adding a DNS TXT record. A verified domain is the safety check that stops a stranger, whose own IdP happens to assert an `@yourcompany.com` address, from being auto-added to your org. Domain verification is its own short setup. See [Domain verification](/products/pro/integrations/authentication/domain-verification/) for the steps and what each verified domain turns on. ### Sync users automatically with SCIM SCIM connects Tallyfy to your identity provider's directory so user accounts stay in sync without anyone clicking around. When someone joins a group in your IdP, they get a Tallyfy account. When they leave, their Tallyfy access is removed and the seat frees up. No more paying for ex-employees. Turn it on under **Settings > Organization > Security > SCIM**. See [SCIM provisioning](/products/pro/integrations/authentication/scim-provisioning/) for how to generate the token and map IdP groups to Tallyfy roles. ### SSO as replacement for e-signatures SSO authentication creates audit trails that can replace e-signature tools for internal approvals. **Why skip traditional e-signatures for internal use?** - Extra cost per signature/user - Separate system to manage - Workflow interruption - users leave Tallyfy, sign elsewhere, then return **SSO-based approvals give you:** - **No extra cost** - included with paid Tallyfy plans - **Identity verification** - corporate SSO confirms the approver's identity - **Audit trail** - every approval logged with timestamp and user identity - **No context switching** - approvers complete tasks without leaving Tallyfy - **Legal compliance** - meets requirements for internal corporate approvals in most jurisdictions **Common use cases:** purchase orders, policy acknowledgments, budget authorizations, project sign-offs, compliance confirmations, HR 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 You can lock your org down so SSO is the only way most people log in. Flip the **Require SSO** switch under **Settings > Organization > Security > SSO**. When enforcement is on: - Email and password logins are turned off for regular members - Manual member invites are blocked, so all users come through your identity provider - Non-SSO login attempts redirect to your SAML login page The switch stays disabled until you have a verified domain, because that's what makes enforcement safe. Turning it on asks you to re-enter your password (a step-up check) and emails every org admin so changes are never silent. **The break-glass guarantee:** org owners and admins keep their password login even under enforcement. If your identity provider goes down or a misconfiguration breaks SSO, an admin can still sign in with a password and fix it. You can't accidentally lock your whole org out. For the full enforcement walk-through and recovery steps, see [SSO enforcement and break-glass](/products/pro/integrations/authentication/sso-enforcement-and-break-glass/). For security background, see the [Compliance documentation on Mandatory Single Sign-On](/products/pro/compliance/#mandatory-single-sign-on-sso). ### SSO authentication flow Here's what happens when someone logs in via SSO: 1. User visits your org's Tallyfy login link 2. Tallyfy redirects to your identity provider (Entra ID, Google, etc.) 3. User authenticates with corporate credentials and MFA 4. Identity provider sends a SAML assertion back to Tallyfy 5. Existing users are matched and logged in. First-time users from a verified domain get an account created automatically from identity provider data (email, first name, last name) when auto-join is on [Diagram removed for brevity] Step 5 is where auto-join matters. If the person already has a Tallyfy account, they're matched on email and logged straight in. If they don't, and their email is on a domain you've verified, Tallyfy creates the account from the email, first name, and last name in the assertion. Without a verified domain, an unknown user is turned away rather than auto-created. ### Supported identity providers #### Microsoft Entra ID (formerly Azure Active Directory) Cloud identity and access management with conditional access and MFA. [**Azure AD Setup Guide →**](/products/pro/integrations/authentication/how-to-integrate-azure-ad-samlsso-with-tallyfy/) #### Google Workspace (formerly G Suite) Identity 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 for enterprise SSO. [**Okta Setup Guide →**](/products/pro/integrations/authentication/how-to-integrate-okta-samlsso-with-tallyfy/) #### OneLogin Identity and access management with SSO capabilities. [**OneLogin Setup Guide →**](/products/pro/integrations/authentication/how-to-integrate-onelogin-samlsso-with-tallyfy/) #### JumpCloud Cloud directory platform with SAML-based SSO. [**JumpCloud Setup Guide →**](/products/pro/integrations/authentication/how-to-integrate-jumpcloud-samlsso-with-tallyfy/) #### Other SAML 2.0 providers Any SAML 2.0-compatible identity provider works. Pick the **Generic SAML** option in the wizard and use the metadata URL or XML paste method. OIDC providers work too via the **Generic OIDC** option. If your provider does something unusual, [Tallyfy support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/) can help you check compatibility. ### Requirements for SSO setup - **A paid plan** - SSO and SCIM are available on any active paid plan - **Admin access** in both Tallyfy and your identity provider - **A verified domain** if you want auto-join or SSO-only enforcement (login alone works without one) - **Attribute mapping** - email, first name, and last name fields from your identity provider to Tallyfy - **Testing** - the wizard's built-in test, plus a check with different user types before rolling out org-wide :::note[SSO with MCP servers] If you're using [MCP servers](/products/pro/integrations/mcp-server/) for AI workflows, SSO can extend to those too. See [SSO authentication with MCP servers](/products/pro/integrations/mcp-server/sso-authentication/). ::: ### Getting started 1. Sign in as an administrator and open **Settings > Organization > Security > SSO** 2. Pick the setup guide for your identity provider above and follow it alongside the wizard 3. Configure the identity provider side, then paste your metadata into Tallyfy 4. Run the connection test, then enable SSO 5. (Optional) Verify your domain, turn on SCIM, and switch on enforcement 6. Test with users from different departments and roles, then tell your team about the new login ### Troubleshooting authentication issues #### Authentication loops If you're stuck in a login loop or can't get past the login screen, visit [https://account.tallyfy.com/logout](https://account.tallyfy.com/logout) to clear all sessions. Then clear your browser cookies for tallyfy.com, wait 10-15 seconds, and log in again. For more details, see the [authentication loop resolution guide](/products/pro/miscellaneous/troubleshooting/#how-do-i-fix-authentication-loops-when-logging-in). #### Common SSO issues | Issue | Solution | |-------|----------| | **Login loops with SSO** | Visit [https://account.tallyfy.com/logout](https://account.tallyfy.com/logout), then re-authenticate | | **Can't switch orgs** | Force logout and clear cookies for all tallyfy.com domains | | **SSO and password login conflict** | Clear all sessions via the logout URL before switching methods | | **"Need admin approval" message** | Your IT admin must approve Tallyfy in the identity provider settings | - **[Tallyfy Analytics](https://tallyfy.com/products/pro/integrations/analytics/)**: Tallyfy Analytics is an add-on that replicates your workflow data into a private Amazon Athena environment where you can run SQL queries and connect BI tools like Tableau or Power BI to build custom dashboards and track process trends over time. ## Tallyfy Analytics overview Tallyfy Analytics is an add-on that copies your workflow data to a dedicated analytical infrastructure - every task, every process, ready for deep analysis. You can connect 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 fast. :::note[Do you actually need a dashboard?] For one-time or exploratory questions, asking Claude through the Tallyfy MCP server is often faster than building a report. See [one-time questions vs recurring dashboards](/products/pro/integrations/analytics/one-time-questions-vs-recurring-dashboards/) to choose the right approach. ::: ### Key features - **Full process data access** - every workflow, task, and form field sits in your analytical database, ready to query. - **SQL query capabilities** - write SQL to slice your data however you need. Join tables, aggregate metrics, filter by date ranges. - **BI tool integration** - works with any tool that supports Amazon Athena[^1], which covers most enterprise BI platforms. - **Custom dashboards** - build exactly the reports your team needs, without waiting on feature requests. - **Trend analysis** - see how your processes evolve over 3, 6, or 12+ months. Historical data tells the real story. ### Operational details - **Add-on service** - contact Tallyfy for details, as availability varies by data volume. - **Private infrastructure** - your data lives in its own Amazon Athena environment. No other accounts can access it. ### Tracking time spent on tasks Tallyfy Analytics captures task completion timestamps automatically, but actual working time needs a different approach. See our guide on [how to track time spent on tasks](/products/pro/tutorials/how-to/track-time-in-tasks/) for implementing clean time tracking with form fields. This captures 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 activate the add-on. Historical data from before activation isn't included. ::: :::note[Timestamp handling in Analytics] All timestamps in Tallyfy Analytics are stored in ISO 8601 format[^2] without timezone information - keeping data consistent for analysis across global teams. In Tallyfy's interface, these timestamps are converted to each user's personal timezone setting. ::: ### Security credentials Once Tallyfy activates 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 and Secret Key pair** - these connect your BI tools to the data. You'll paste them into Power BI, Tableau, or whatever tool you use. ### Getting started Contact Tallyfy support or your account manager to get started. They'll walk you through setup and configuration. [^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 - **[Business systems integrations](https://tallyfy.com/products/pro/integrations/business-systems/)**: Tallyfy connects business operating systems like EOS® and Scaling Up to daily execution. It turns documented processes into trackable workflows with real-time visibility, so strategy doesn't stall on Monday morning. ## Tallyfy and business operating systems Business operating systems give you the strategic plan, but they don't tell you how to actually execute processes day-to-day. Tallyfy fills that gap by turning your documented processes into trackable workflows that work with whatever approach you're already using. ### What types of business systems does Tallyfy support? Tallyfy handles the execution piece that these systems usually gloss over: **Operating systems** - EOS® (Entrepreneurial Operating System®) - Complete process component support - Scaling Up - Execution system for documented processes - Traction - Operational accountability and tracking **Management methods** - 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 cover strategic planning, goal setting, and vision casting well. But when Monday morning rolls around - that's where they fall short. **Strategic vs. tactical gap** - Business systems define *what* needs to happen - Tallyfy ensures *how* it happens consistently **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? CRMs only track milestones - not the actual work behind them. Tallyfy fills this gap so every micro-task gets assigned, tracked, and completed in the right sequence. **Documentation vs. execution** - You've got binders full of documented processes - but who's actually following them? - Tallyfy turns those documents into workflows people actually use **Accountability and visibility** - Can you see who's doing what right now? Usually not. - Live tracking replaces "I think we're on track" with real data ### Enhancing business system implementations #### Process component activation Documented processes become real workflows with automatic routing, deadlines, and progress tracking that shows what's actually happening. #### Real-time operational visibility Leadership meetings become productive when you're looking at live data instead of asking "where are we on this?" #### Continuous improvement integration Which processes take too long? Where do things get stuck? Tallyfy's 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 tribal knowledge, no "that's not how we do it at the other office." ### What implementation approach works best? #### Start with core processes Pick 2-3 processes that directly hit your scorecard metrics. Get those running smoothly first. #### Align with existing meetings Add process execution data to your existing weekly meetings and quarterly planning sessions. 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 - skip it. #### Scale systematically Once your team sees those first processes working, they'll want more. Expand when people are pulling for it, not when you're pushing. Most business systems fail because they can't bridge strategy and execution. Tallyfy makes your business system work in the real world - where processes need to run every day, not just during planning sessions. - **[BYO AI (Bring Your Own AI)](https://tallyfy.com/products/pro/integrations/byo-ai/)**: BYO AI connects your existing AI subscriptions like ChatGPT or Claude directly into Tallyfy workflows through the MCP standard. Your AI can read task context, complete steps, generate content, and make decisions automatically without any copy-pasting. Tallyfy table view showing a 4-step client onboarding workflow where AI drafts and a human approves, illustrating how BYO AI fits inside Tallyfy :::note[MCP industry standard] BYO AI uses MCP (Model Context Protocol), 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. ::: ## Put your AI subscription to work inside Tallyfy workflows BYO AI (Bring Your Own AI) connects your existing AI subscriptions - ChatGPT Plus, Claude Pro, Google Gemini, or Microsoft Copilot - directly into your Tallyfy workflows. Your AI becomes a team member that completes tasks, writes documents, analyzes data, and makes decisions right inside running processes. Most people have AI subscriptions they barely use. BYO AI changes that by embedding AI assistance into your actual workflow steps - so it works for you automatically, using the subscription you're already paying for. ### Why this matters Without BYO AI, using AI in a workflow means copying text from a document, pasting it into ChatGPT, waiting for a response, then copying that back into another system. It's manual and disconnected. BYO AI eliminates this. 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 needed. No app-switching. The AI works right where the work happens. ### How authentication works BYO AI authenticates through OAuth2 - the same secure method you use when signing into websites with Google or Microsoft. 1. **You authorize once** - connect your AI account to Tallyfy through a secure OAuth flow 2. **Tallyfy stores tokens** - your authentication tokens stay secure (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 subscription stays yours. Tallyfy just bridges your workflows and your AI assistant. ## Why Tallyfy is the AI control layer | What Tallyfy does | Why it matters in the age of AI | |---|---| | Define process steps | You can't automate anything without a recipe. | | Hand small tasks to AI | Massive reduction in mistakes, omissions, and hallucination. | | People approve work | Accountability. You can't blame AI for mistakes. | | Hybrid people + AI tasks | AI can't do every task in a process. | | Track real-time status | Tracking AI sessions at scale is a nightmare. | | Gradually shift tasks to AI | A total re-do will break a process that works today. | ### 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 embedded in templates #### Content generation Instead of blank form fields, users see AI-generated suggestions: - Draft emails based on process context - Reports from collected data - Summaries of long documents - Translations 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 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 in the right processes. **Data analysis** - AI analyzes spreadsheet uploads, generates insights, and creates summary reports without anyone opening 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 and optimization** - planned - AI learns from your process history - Suggests template improvements - Predictive automation ### Security and 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 1. Pick your AI platform (ChatGPT, Claude, Google Gemini, or Microsoft Copilot) 2. Follow the connection guide for your platform (see below) 3. Complete the OAuth authorization flow to connect your Tallyfy account 4. Your AI can now interact with Tallyfy using natural language For technical details (endpoints, scopes, authentication), see the [MCP server integration](/products/pro/integrations/mcp-server/) documentation and the platform-specific setup guides below. ### Practical use cases Once your AI is connected, what can you actually do with it? The [use cases](/products/pro/integrations/byo-ai/use-cases/) section has 14 ready-to-use guides - from getting a daily task briefing to building templates through conversation to generating reports from process data. Each guide includes copy-paste prompts for Claude, ChatGPT, Copilot, and Gemini. ### Related integration approaches - [MCP server integration](/products/pro/integrations/mcp-server/) - full technical details, available tools, and platform-specific setup guides - [Computer AI agents](/products/pro/integrations/computer-ai-agents/) for screen automation - [API integration](/products/pro/integrations/open-api/) for custom AI implementations - [Webhook automations](/products/pro/integrations/webhooks/) for event-driven AI triggers - **[Tallyfy CLI](https://tallyfy.com/products/pro/integrations/cli/)**: The Tallyfy CLI brings scriptable workflow automation to any terminal or pipeline. Install it with Homebrew or a direct download, sign in once, then launch processes, export blueprints, and gate deployments on human approval from the command line. ## Automate Tallyfy from your terminal The Tallyfy CLI is the official command line tool for Tallyfy. It lets you launch processes, complete tasks, export and import blueprints, and hold a software release until a person signs off. Everything works from a plain terminal or an automated pipeline, on macOS, Windows, and Linux. It's built for people who automate things: IT admins onboarding fifty employees from a spreadsheet, developers adding approval gates to a deployment pipeline, and operations teams who'd rather type one command than click through twenty screens. The CLI is brand new (version 0.1.0), free, and open source under Apache 2.0. Source code and releases live at [github.com/tallyfy/cli](https://github.com/tallyfy/cli)[1]. ### Install the CLI **Homebrew** (macOS and Linux): ```bash brew install tallyfy/tap/tallyfy ``` **Direct download**: grab the binary for your platform from the [releases page](https://github.com/tallyfy/cli/releases)[2], verify the checksum, and put it on your PATH. Version 0.1.0 binaries aren't code-signed yet, so macOS may quarantine a direct download - the [troubleshooting guide](/products/pro/integrations/cli/troubleshooting/) has the one-line fix. **Go developers** can build from source: ```bash go install github.com/tallyfy/cli/cmd/tallyfy@latest ``` ### Your first five minutes **1. Sign in.** This opens your Tallyfy settings in a browser so you can copy your personal access token, then stores it securely: ```bash tallyfy login ``` **2. Pick the organization to work in:** ```bash tallyfy org list tallyfy org use YOUR_ORG_ID ``` **3. Confirm who you are, then look around:** ```bash tallyfy whoami tallyfy blueprint list ``` That's it. You're signed in, pointed at the right organization, and listing your workflow templates. The [authentication guide](/products/pro/integrations/cli/authentication/) covers scripts and CI setups, and the [command reference](/products/pro/integrations/cli/command-reference/) covers everything else the CLI can do. ### One surface among four Tallyfy gives you four ways to get work done, and they complement each other: | Surface | Driven by | Best for | |---|---|---| | Web app | People clicking | Daily work, tracking, building [templates](/products/pro/documenting/templates/). | | REST API | Your own software | Custom product integrations. | | MCP server | AI assistants | Plain-English requests and small, reviewed changes. | | CLI | Scripts and pipelines | Repeatable jobs, bulk work, CI/CD gates. | Not sure which fits your job? The [decision guide](/products/pro/integrations/cli/cli-vs-api-vs-mcp/) compares all four in detail. :::note[Telemetry is off by default] The CLI doesn't collect usage analytics unless you opt in. Nothing about what you automate leaves your machine except the API calls you asked for. ::: ### What you can automate - Launch one process, or hundreds from a CSV file, with [bulk operations](/products/pro/integrations/cli/bulk-operations/). - Export blueprints to JSON and manage them like code with [workflows as code](/products/pro/integrations/cli/workflows-as-code/). - Pause a pipeline until someone approves, using [CI/CD approval gates](/products/pro/integrations/cli/ci-cd-approval-gates/). - Manage members, guests, groups, folders, and tags from the [command reference](/products/pro/integrations/cli/command-reference/). - Control exactly what the CLI may do with [configuration and permissions](/products/pro/integrations/cli/configuration-and-permissions/). - **[Computer AI agents](https://tallyfy.com/products/pro/integrations/computer-ai-agents/)**: Computer AI agents visually interpret and interact with any screen-based interface like a human would. Tallyfy sends instructions and captures results so you can monitor these agents alongside your broader business processes. Tallyfy table view showing a 4-step workflow that mixes people, AI agents, and conditional triggers, illustrating how computer AI agents fit inside a defined Tallyfy process :::note[This space moves fast] Computer AI agent technology is evolving quickly. Check vendor docs for current features and pricing. ::: ## What are computer AI agents? Computer AI agents are programs that can see your screen, understand it, and take action. Unlike traditional automation that needs specific API connections, these agents browse websites, fill forms, and extract data from any interface by interpreting visual elements. Think of them as automation that works like a person would - clicking buttons, typing text, reading what's displayed - but without custom code for every app. For conversational AI that works with text and documents rather than screens, see the [BYO AI integration](/products/pro/integrations/byo-ai/) connecting ChatGPT, Claude, or Copilot. One thing worth knowing before you point an agent at a long process: AI reliability drops fast across a chain of steps. The [AI task reliability calculator](https://tallyfy.com/tools/ai-task-reliability/) shows why giving AI one task at a time beats handing it a whole job. ### How Tallyfy works with AI agents Tallyfy provides structure around AI agent execution. It gives step-by-step instructions and defines inputs and outputs, while the agent handles screen-based tasks. This separation means you can see what the agent's doing and manage automated steps alongside your broader processes. ## Why Tallyfy is the AI control layer | What Tallyfy does | Why it matters in the age of AI | |---|---| | Define process steps | You can't automate anything without a recipe. | | Hand small tasks to AI | Massive reduction in mistakes, omissions, and hallucination. | | People approve work | Accountability. You can't blame AI for mistakes. | | Hybrid people + AI tasks | AI can't do every task in a process. | | Track real-time status | Tracking AI sessions at scale is a nightmare. | | Gradually shift tasks to AI | A total re-do will break a process that works today. | ### Core capabilities These agents combine large language models with computer vision to interact with apps through their UI: - **Visual perception** - Identify and interpret text, buttons, forms, and other screen elements - **Plain language instructions** - Accept goals in everyday English instead of scripted code - **Mouse and keyboard control** - Click, type, scroll, and move through pages just like a person - **UI adaptation** - Often handle interface changes that would break traditional RPA scripts :::warning[Start small] AI agents work best with straightforward, repetitive tasks - like filling form fields with known values. Complex work requiring judgment can produce inconsistent results and high costs. Start small and expand gradually. ::: ### Integration pattern [Diagram removed for brevity] **Key points:** - Tallyfy sends structured inputs (instructions, data, criteria) to guide the agent - The agent loops through perceive-act-verify cycles until the task's done - Results flow back into the workflow for tracking and next steps **How it works in practice:** 1. **Map your process** - Identify which steps humans do and which an AI agent could handle 2. **Assign agent tasks** - Web navigation, data extraction, or form filling are good candidates 3. **Send instructions** - Tallyfy passes instructions and data from previous steps to the agent 4. **Monitor execution** - Agent actions get logged for troubleshooting 5. **Capture results** - Outputs return to Tallyfy for the next step 6. **Iterate** - Adjust instructions based on results to improve reliability ### Benefits and limitations **What you gain:** - **Wider automation reach** - Works with apps that lack APIs or integration options - **Less manual work** - Handles repetitive screen tasks that previously needed a person - **UI resilience** - Can often adapt when interfaces change, though it's not guaranteed - **Visibility** - When coordinated through Tallyfy, agent actions get logged and tracked **What to watch out for:** - **Reliability varies** - Success rates depend on task complexity, site structure, and the vendor - **Costs scale quickly** - Many vendors charge per task or by execution time - **Not deterministic** - Unlike traditional code, agents may behave differently each run - **Still emerging** - Vendor capabilities, pricing, and availability keep changing - **[Document management](https://tallyfy.com/products/pro/integrations/document-management/)**: Connect your document management system to Tallyfy so workflows handle task assignments and timing. Your DMS keeps full control over storage and security, while file request links let external users upload directly without needing accounts. ## Connect your document management system to Tallyfy You can connect your existing document management system (DMS) to Tallyfy workflows. Keep your current security protocols and document storage in place - Tallyfy orchestrates the workflow around those documents. Tallyfy handles the "who does what and when" while your DMS handles "where documents live and how they're secured." ## Choose your document strategy You've got two paths when handling documents in workflows. ### Use your existing DMS **Good 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 **Advantages:** - Documents stay in your secured, compliant environment - Existing access controls and audit trails remain intact - No file size limits from Tallyfy - Keep using DMS features like versioning, encryption, and retention policies **Trade-offs:** - Requires initial setup of file request links - Users interact with two systems ### Use Tallyfy's built-in file management **Good for:** - Simple document workflows without special compliance needs - Teams wanting everything in one place - Quick implementations without IT involvement **Advantages:** - Single system for users to learn - Files attach directly to tasks - No integration needed - Built-in commenting on files **Trade-offs:** - 100MB file size limit per upload - Less granular access controls - Storage counts toward your Tallyfy plan limits ## The hybrid approach Many organizations handle sensitive documents through their DMS while using Tallyfy's file uploads for routine attachments like screenshots or simple forms. For example, 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 how it works: 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 the link with the person who needs to upload 4. They click it and upload directly to your DMS 5. Your team accesses documents from the DMS Documents never pass through Tallyfy - your security boundary stays intact. ## Security considerations **Data sovereignty** - Documents remain in your controlled environment, which matters for data residency requirements. **Compliance** - Your existing certifications and controls stay intact. **Access control** - DMS permissions determine who sees what, independent of Tallyfy access. **Audit trails** - Document access logs stay in your DMS for compliance reporting. ## Implementation patterns ### Individual file requests Generate unique upload links for each process instance. Best for collecting sensitive documents from different clients or patients. ### Shared collection folders Use the same upload link across multiple process runs. Works well for internal document submission where security is less critical. ### Automated link generation Use your DMS API to automatically generate fresh upload links when launching processes. This requires technical setup but gives the smoothest experience. ## Getting started Start with the guide on [file request links](mdc:products/pro/integrations/document-management/file-request-links/), then explore vendor-specific implementations for your DMS platform. - **[Email and SMTP](https://tallyfy.com/products/pro/integrations/email/)**: Tallyfy connects with email through custom SMTP for branded notifications, a Gmail add-on for managing workflows from your inbox, and upcoming features for in-email actions and personal email connections. ## Email integration options Tallyfy connects with email in several ways - custom SMTP, a Gmail add-on, automated notifications, interactive actions (coming soon), and personalized email sending (coming soon). Your team already lives in email. These integrations bring Tallyfy's workflow capabilities directly into the inbox. ### Custom SMTP configuration Tallyfy lets you configure a custom SMTP server so all workflow notifications come from your own domain (e.g. yourcompany.com) instead of Tallyfy's servers. You'll need to provide SMTP host, port, username, password, and optionally a from address and from name. #### Why use custom SMTP? - **Branding** - Emails come from your company domain, keeping your brand consistent. - **Deliverability** - Uses your organization's established email reputation. - **Compliance** - Keeps email communication within your company's controlled systems. - **Filtering** - Works with your organization's existing email rules and security 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 **won't work**. Replies go to the SMTP sender address 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/).)* ### Tallyfy Gmail add-on The Tallyfy [Gmail add-on](/products/pro/integrations/email/how-can-i-manage-my-tasks-with-tallyfys-gmail-add-on/) lets you manage workflows without leaving Gmail. - **Start processes** - Launch a process directly from an email. - **Email-to-task conversion** - Turn an email into a trackable task with deadlines and assignments. - **Task management** - View and complete your tasks right inside Gmail. ### Managing email notifications 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). See [Manage email notifications](/products/pro/settings/personal-settings/how-can-i-manage-email-notifications-in-tallyfy/) to customize your settings. ### Interactive email actions (coming soon) Imagine getting a Tallyfy notification about an approval task and hitting "Approve" right in the email - without opening the app. That's what [interactive email actions](/products/pro/integrations/interactive-email-actions/) will enable. Microsoft Outlook calls them Actionable Messages, Gmail calls them Markup Actions. You'll be able to approve tasks, add comments, and complete simple actions directly from your email client. ### Connect your email (coming soon) This upcoming feature will let individual users [connect their personal email accounts](/products/pro/integrations/email/connect-your-email/) (Gmail or Outlook) to send workflow emails from their own address. Unlike custom SMTP - which uses one centralized system email for the whole organization - this creates a one-to-one connection between each user and their email account. When Sarah assigns you a task, you'd see it coming from sarah@yourcompany.com, not from notifications@yourcompany.com. - **[Actions within emails](https://tallyfy.com/products/pro/integrations/interactive-email-actions/)**: Tallyfy's exploring interactive email actions that let users approve requests and complete tasks directly in Outlook or Gmail. This would use Microsoft Adaptive Cards and Gmail schema.org markup. ## Take action on tasks directly from email You can't - yet. But we're working on it. Interactive email actions would let you complete Tallyfy tasks right inside your email - approve requests, mark tasks done, add comments - without switching apps. The technology exists through **Microsoft Actionable Messages** for Outlook and **Gmail Markup Actions** for Gmail, and we're exploring how to bring it to Tallyfy. > Tallyfy emails already include basic `schema.org` ViewAction markup, which gives Gmail a "View in Tallyfy" button. Interactive email actions would go further - letting you take action without leaving your inbox. ### What are interactive email actions? Buttons and forms that work inside your email. You'd approve a request, mark a task complete, or add a comment without clicking a link or opening another tab. Traditional emails make you click through to a web page. Interactive emails bring the action to you. #### Microsoft Actionable Messages Microsoft embeds "Adaptive Cards" into Outlook emails. These cards display information and let you act on it: * 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. Learn more on [Microsoft Learn](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 to show interactive elements. Two main types exist: * **One-Click Actions**: For approvals and confirmations - one tap and you're done * **Go-To Actions**: For actions that need a full webpage When you click an action, Gmail sends it back to the service. See the [Google Developers documentation](https://developers.google.com/workspace/gmail/markup/actions/actions-overview) for technical details. ### How this would benefit Tallyfy users Switching between email and web apps slows you down. Interactive emails would fix that: * **Speed**: Approve requests without login screens or page loads. * **Focus**: Handle quick actions from your inbox without breaking your flow. * **Mobile-friendly**: One-tap actions instead of logging into a web app on your phone. ### Potential use cases * **One-click approvals/rejections**: Get an approval request, click **Approve** or **Reject**, done. * **Marking tasks complete**: One button in the email for tasks that just need acknowledgment. * **Adding quick comments**: Reply to the email and your comment gets added to the task. * **Simple form submissions**: Pick an option or enter a short response directly in the email. ### What's next? This isn't live yet - we're still exploring. Interactive emails require strong security and consistent behavior across email clients, which takes time. We'll share updates as this progresses. - **[MCP server](https://tallyfy.com/products/pro/integrations/mcp-server/)**: Tallyfy's MCP Server lets you control workflows through plain English in ChatGPT, Claude, Gemini, or Copilot. Search tasks, launch processes, manage templates, and set up automations without any API knowledge. ## Tallyfy MCP server Chat with your AI assistant to run Tallyfy in plain English. Ask ChatGPT, Claude, Gemini, or Microsoft Copilot to find a task, launch a process, or clean up a template, and it does the work for you. In ChatGPT, Claude and Gemini there's no code to write and no API key to paste: you sign in once with your Tallyfy account and the assistant handles the rest. Copilot Studio is the exception, because it reaches Tallyfy through a Power Platform custom connector that someone has to build and give a credential to. Tallyfy's MCP server is the bridge that makes this possible. MCP (Model Context Protocol) is the shared standard that lets AI assistants connect to outside tools, and every major AI provider supports it. You stay in charge the whole time: the AI only sees what you allow, and it follows your existing Tallyfy permissions on every action. Want the simplest possible setup, using an AI subscription you already pay for? See our [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, run by the Agentic AI Foundation under the Linux Foundation, so no single vendor owns it. It opens a safe connection between an AI model and a system like Tallyfy, and you decide what that AI is allowed to touch. OpenAI, Anthropic, Google, and Microsoft all support it. ### What you can do Tallyfy's MCP server gives your AI assistant more than 100 tools that connect straight to your Tallyfy organization. Sign in securely from your AI tool, or use a Tallyfy API token, and you can: - Ask plain-English questions about your [processes](/products/pro/tracking-and-tasks/processes/) and [tasks](/products/pro/tracking-and-tasks/tasks/) - Create, complete, and manage tasks by chatting - Launch and manage [processes](/products/pro/tracking-and-tasks/processes/) directly - Analyze [templates](/products/pro/documenting/templates/) and get improvement suggestions - Search across your whole organization's workflows - Manage [users](/products/pro/documenting/members/) and [guests](/products/pro/documenting/guests/) For example: - "Show me all overdue tasks for John" - "Launch the Employee Onboarding process for Jane Doe" - "What templates do we have for customer onboarding?" - "Assess the health of our 'Employee Onboarding' template" ### Capabilities in detail The server's tools cover these areas, all callable from any MCP-compatible AI: **Search and discovery** Find tasks, processes, templates, snippets, or do a unified search across all entity types in plain English. - "Find all tasks related to budget approval" - "Search for processes containing 'customer onboarding'" - "Show me templates for HR workflows" **User and access management** List and manage [members](/products/pro/documenting/members/), [guests](/products/pro/documenting/guests/), groups, and roles. Invite new users, change roles, enable or disable accounts. **Task management** View your own tasks, list tasks assigned to teammates, see all tasks within a [process](/products/pro/tracking-and-tasks/processes/), create standalone tasks from natural language, complete or reopen tasks, update titles and deadlines, manage comments, and report or resolve task issues. **Process management** List running [processes](/products/pro/tracking-and-tasks/processes/), launch new ones from a [template](/products/pro/documenting/templates/), view or update process state, archive completed processes, and reactivate archived ones. **Template design and optimization** Get any template's detail or a full inventory, view steps, run a health assessment, see step dependencies and visibility conditions, get deadline recommendations, modify template properties, clone templates, and add or reorder steps. **Form field management** Add [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) to steps, update properties, move fields between steps, reorder fields, delete fields, get AI suggestions for useful fields, and manage dropdown options. **Kickoff fields** View, add, update, reorder, and delete kickoff (prerun) fields on templates. Get dropdown, radio, and multiselect options for kickoff fields. Get AI recommendations for process launch form fields, and complete or reopen the kickoff form on a process. **Automation and workflow logic** Create, update, and delete [automation rules](/products/pro/documenting/templates/automations/). Review all rules with duplicate detection, get consolidation recommendations that flag orphaned rules and merge candidates, and inspect step visibility conditions. **Organization tools** Manage tags, [folders](/products/pro/documenting/templates/), and tags on templates and processes. **Building templates from a description** Describe the process you want and your AI assistant builds it for you, step by step. It creates the template, adds each step, and sets up the kick-off form fields. You review and adjust as it goes, so nothing lands in your account that you haven't seen. There's no single "generate a template" button here. Your assistant does it the same way you would, one action at a time, which means you can stop or change direction at any point. ### Is it secure? Yes. Only people you've authorized can reach your data, and every action follows the Tallyfy permissions that person already has. You sign in through a secure, token-based flow, so the AI never handles a password, and you choose exactly what it can read or change. Every action is logged. And because the server is open source, anyone can check exactly how it works. The technical setup lives in the [For developers](#for-developers) section near the bottom. ### Available MCP integrations Pick your AI platform: - **[Claude (Anthropic)](/products/pro/integrations/mcp-server/claude-anthropic/)** - Remote MCP for Claude Desktop, claude.ai connectors, and Claude Code on Pro, Max, Team, and Enterprise plans - **[ChatGPT (OpenAI)](/products/pro/integrations/mcp-server/openai-chatgpt/)** - Custom Connector + ChatGPT Apps on Pro/Plus/Team/Enterprise/Education plans - **[Google Gemini](/products/pro/integrations/mcp-server/google-gemini/)** - Gemini CLI MCP config and Gemini Enterprise custom MCP data store - **[Microsoft Copilot Studio](/products/pro/integrations/mcp-server/microsoft-copilot-studio/)** - Custom MCP connector, Power Platform certified path - **Cursor, Cline, Continue** - Standard MCP server config in your `.mcp.json` or workspace settings - **MCP Inspector and CLI tools** - Connect via the standard streamable-http transport ### Coming soon - Advanced reports with charts and insights - Connections to other [middleware](/products/pro/integrations/middleware/) platforms - Real-time team collaboration features ## Limitations of text-based AI interfaces MCP is powerful, but text-based AI chat has real limits when you're working with Tallyfy's visual workflow features: :::note[Bulk and headless work belongs in the CLI] The MCP server deliberately refuses bulk changes touching more than 5 items in one request. For CSV launches, scheduled scripts, and CI/CD pipelines, use the [Tallyfy CLI](/products/pro/integrations/cli/) instead. ::: ### Visual interface constraints - **No process tracker**: Can't display Tallyfy's bird's-eye view of running [processes](/products/pro/tracking-and-tasks/processes/) with progress indicators - **No template builder**: Can't show the drag-and-drop interface or visualize step dependencies - **No aggregated views**: Can't present filterable views of processes and tasks at a glance - **No live updates**: Can't show real-time progress as team members complete tasks ### Form field challenges - **Dropdowns**: Text-based AI must list all options as plain text, making selection tedious - **Multi-select inputs**: Form inputs lose their visual interface when reduced to text - **Date/time pickers**: Calendar and time tools become manual text entry - **File uploads**: Can't handle file uploads through conversation ### Assignment and collaboration barriers - **Assignee selection**: Can't show Tallyfy's visual suggestions for [members](/products/pro/documenting/members/), [guests](/products/pro/documenting/guests/), job titles, and groups - **Bulk operations**: Managing multiple assignments through individual text commands is slow - **Collaboration**: Real-time features like simultaneous template editing become sequential ### Template creation limitations - **Step visualization**: Can't display all steps at once or show their relationships visually - **Reordering**: No drag-and-drop - must use text commands - **Automation setup**: Complex [automation rules](/products/pro/documenting/templates/automations/) are harder to configure through conversation - **Preview**: Can't visually preview how a template will work before deploying it ## Where MCP works best Text-based MCP shines in specific scenarios: ### Search and discovery Ask specific questions, get targeted answers: - "Find all templates related to employee onboarding that include background check steps" - "Show me all customer onboarding processes that took longer than 5 days" - "Which tasks are overdue and assigned to the sales team?" - "Find templates that use the 'Budget Approval' form field" ### Template generation from documents Got a messy document? AI turns it into structured templates: - **Form field creation**: Upload forms and let AI generate [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) with validation rules - **Flowchart conversion**: Turn process diagrams into [templates](/products/pro/documenting/templates/) with proper step sequences - **Automation generation**: Convert plain-language business rules into [automation rules](/products/pro/documenting/templates/automations/) - **Bulk field creation**: Generate multiple related form fields from document analysis ### What-if scenario testing - "If I set up an automation to route tasks by deal value, how would it handle these 5 example deals?" - "What would happen if we removed the approval step for purchases under $1,000?" - "How would task distribution change if we reassigned John's templates to Sarah?" - "Based on historical data, estimate completion time if we add a review step" ### Process updates from changed documents Compliance docs changed? AI spots differences and updates everything: - "Here's our updated SOX compliance procedure. Update our audit template to match" - AI identifies exactly what changed and updates only affected parts - Compare old and new documents to generate precise template modifications - Apply consistent changes across multiple templates from policy updates ### Pattern recognition and optimization - "Look at one-off tasks added to hiring processes last month - which should become permanent template steps?" - "Which steps consistently cause delays?" - "Find similar templates that could be merged into one" - "Identify patterns in high-performing processes and suggest improvements" ### Reporting with citations - "Which step in our sales process has the longest average completion time?" - "Show all instances where required approvals were skipped, with links to the processes" - "How has customer onboarding time changed over the last 6 months?" - "Which departments most frequently add ad-hoc tasks?" ## What it looks like in Claude Real screenshots from claude.ai with the Tallyfy connector active. The full set with longer captions lives in the [Claude integration guide](/products/pro/integrations/mcp-server/claude-anthropic/) - here are four highlights. **Building a workflow from a flowchart.** Drop in a flowchart, get a working Tallyfy template with steps and conditional automation rules. ![Claude creating a 7-step Business Trip Request template in Tallyfy with 5 automation rules matching a flowchart](https://screenshots.tallyfy.com/tallyfy/pro/mcp-claude-template-creation.png) **Confirming scope before pulling data.** Claude uses the `ask_user_question` MCP tool to clarify ambiguous requests before any tools fire. ![Claude.ai Cowork sidebar showing the Tallyfy connector connected, with Claude asking four clarifying questions before querying pending tasks](https://screenshots.tallyfy.com/tallyfy/pro/mcp-claude-clarifying-questions.png) **Reviewing an existing process.** Asked to review a Client Onboarding workflow, Claude confirms whether you want suggestions only, edit-on-approval, or direct edits. ![Claude.ai Cowork sidebar reviewing a Client Onboarding process and confirming desired scope via a four-option picker](https://screenshots.tallyfy.com/tallyfy/pro/mcp-claude-process-review.png) **Multi-tool analysis with progress tracking.** Claude chains `get_me`, `get_my_tasks`, and counting/verification logic. The result: 822 open tasks, 805 explicitly overdue, zero due in the next 30 days because everything is already past its date. ![Claude.ai answering a pending-tasks question against the Tallyfy MCP server, with the progress sidebar showing four completed sub-steps and a detailed breakdown of 822 open tasks](https://screenshots.tallyfy.com/tallyfy/pro/mcp-claude-overdue-analysis.png) ## Why Tallyfy is the AI control layer | What Tallyfy does | Why it matters in the age of AI | |---|---| | Define process steps | You can't automate anything without a recipe. | | Hand small tasks to AI | Massive reduction in mistakes, omissions, and hallucination. | | People approve work | Accountability. You can't blame AI for mistakes. | | Hybrid people + AI tasks | AI can't do every task in a process. | | Track real-time status | Tracking AI sessions at scale is a nightmare. | | Gradually shift tasks to AI | A total re-do will break a process that works today. | ## For developers *(Skip this unless you're setting up the technical side.)* ### Where the server is listed - Published on the [Official MCP Registry](https://registry.modelcontextprotocol.io/?q=tallyfy) as `com.tallyfy/mcp-server` (DNS-verified, version 1.1.2) and on [Smithery](https://smithery.ai/server/@tallyfy-inc/mcp-server). - Listed in the [GitHub MCP Registry](https://github.com/mcp/com.tallyfy/mcp-server) as **Tallyfy Workflow Automation**, so you can find and install Tallyfy straight from [github.com/mcp](https://github.com/mcp). - Compatible clients: **OpenAI ChatGPT**, **Anthropic Claude** (Desktop, claude.ai, Claude Code), **Google Gemini**, **Microsoft Copilot Studio**, **Cursor**, **Cline**, **Continue**, and any other MCP-compatible AI client. - MCP Inspector and CLI tools connect via the standard streamable-http transport. - 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. ### Security and authentication The MCP server uses OAuth 2.1 with PKCE for secure authentication. The well-known endpoint at `/.well-known/oauth-authorization-server` (per RFC 8414) lets AI clients discover authorization endpoints automatically. OAuth scopes use dot notation - for example, `mcp.tasks.read`, `mcp.processes.write`, `mcp.templates.read`. Key security features: - Only authorized users can access your organization's data - Every action respects your existing permissions - Audit trails track who did what - Dynamic Client Registration (RFC 7591) with redirect URI validation - Refresh token rotation with reuse detection - Authorize button stays disabled until you check at least one scope - Successful deep-link consent auto-closes the consent window so you return to your AI client without manual action - Cancelling consent returns a clean error page instead of raw protocol output ### Recent updates - **OWASP MCP Top-10 audit closed (May 2026)** - the server passed a full OWASP MCP-specific threat model with hardening for prompt injection, indirect tool calls, scope confusion, and token leakage paths - **Cloud Run mirror operational (May 2026)** - `https://mcp-gcp.tallyfy.com/` brought up as the Tier-1 origin for Gemini Enterprise customers; the Google Cloud build pipeline is now unblocked and deploys on every push - **Cross-process structured logging** - the MCP host's request/response audit trail now flows into Tallyfy's central logging backend, joining the same observability stack as API and email events ### Technical architecture The MCP server is built from: - **Core SDK** - Python client that calls Tallyfy's API - **MCP server** - The protocol implementation, built on FastMCP, transport is streamable-http - **Tool system** - Structured tool definitions that tell AI clients what actions are available, with `ToolAnnotations` (read-only or destructive hints) on every tool - **OAuth 2.1 layer** - Dynamic Client Registration (RFC 7591), PKCE S256, RS256-signed JWT access tokens with refresh-token rotation Public endpoints: - `https://mcp.tallyfy.com/` - the primary streamable-http MCP endpoint (DigitalOcean) - `https://mcp-gcp.tallyfy.com/` - the Google Cloud Run mirror (Tier-1 path for Gemini Enterprise) - `https://mcp.tallyfy.com/.well-known/oauth-protected-resource` - OAuth resource metadata - `https://mcp.tallyfy.com/.well-known/oauth-authorization-server` - OAuth authorization server metadata - `https://mcp.tallyfy.com/.well-known/jwks.json` - public RS256 signing key - `https://mcp.tallyfy.com/.well-known/openai-apps-challenge` - OpenAI Apps directory verification challenge - `https://mcp.tallyfy.com/health` - health check - `https://mcp.tallyfy.com/privacy` - MCP-specific privacy summary Both endpoints share the same OAuth backend, the same 109 tools, and the same Tallyfy organization data. Pick `mcp.tallyfy.com` by default; use `mcp-gcp.tallyfy.com` when your AI platform (Gemini Enterprise in particular) prefers a Google Cloud-hosted origin. The server is open source under Apache 2.0, so you're free to review exactly what every tool does, audit the OAuth flow, or run your own instance. The code lives at [github.com/tallyfy/mcp-public](https://github.com/tallyfy/mcp-public)[1]. - **[Open API](https://tallyfy.com/products/pro/integrations/open-api/)**: Tallyfy's REST API gives developers full programmatic access to the same platform features that power its web app. It covers process management, task operations, template control, and data export with three authentication methods, standard JSON responses, and required headers. ## Tallyfy REST API overview The Tallyfy REST API lets developers build custom integrations with core platform features through code. Tallyfy's "API-first" approach means the public API gives you the same functionality that powers our web app. Everything we've built for ourselves, you get too. We depend on these APIs just as much as you do - so they're stable and well-maintained. 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. :::note[Technical audience] This section is intended for developers or those working with development teams. ::: :::note[API names differ from app names] The Tallyfy API uses different names than the web app. For example, templates are called `checklists` and processes are called `runs` in API endpoints. See the [full mapping](/products/pro/integrations/open-api/how-to-integrate-with-tallyfy-using-api/#api-terminology) in the API integration guide. ::: ### API fundamentals | Environment | Base URL | Documentation | |-------------|---------------------------|----------------------------------------| | Production | `https://go.tallyfy.com/api/` | [Tallyfy API reference](https://go.tallyfy.com/api/) | ### Authentication methods Tallyfy provides three authentication methods for API access: 1. **User token authentication** - Get a token for a specific Tallyfy user (from their profile or through the API). Your app works with that user's exact permissions. - **Note**: Personal access tokens are invalidated when users log out. For long-running automations, use application tokens instead. 2. **Application token authentication** - Get app-level credentials (client ID and secret) so your application can act on behalf of multiple users. Ideal for server-to-server connections. 3. **OAuth authentication flow** - The industry-standard way to let users grant 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 headers: ``` Authorization: Bearer {your_access_token} Accept: application/json X-Tallyfy-Client: APIClient ``` :::caution[X-Tallyfy-Client header is mandatory] Your code *must* include `X-Tallyfy-Client: APIClient`. Requests without it will fail - typically returning "endpoint not found" or a 401 error. ::: ### Available API operations The API provides access to core Tallyfy features: | Category | Operations | |-----------------------|---------------------------------------------------------| | **Process management**| Launch processes, monitor status, cancel runs | | **Task operations** | Complete tasks, update form data, manage comments | | **User management**| Create/manage users, configure roles and permissions | | **Template control** | Create/update templates, manage steps and form fields | | **Data export** | Export process data, retrieve reporting information | | **File management** | Upload files, manage attachments | ### API response format Tallyfy API responses follow standard conventions: - All data returns as JSON. - Standard HTTP status codes indicate outcomes (200 for success, 4xx/5xx for errors). - Error responses include clear error messages. - List endpoints support pagination. ### Rate limits Tallyfy limits how fast you can call the API at two layers. When you cross a limit, the API returns HTTP 429 with a `Retry-After` header telling you how many seconds to wait before retrying. - **Burst protection**: rapid bursts of requests from one user or IP address get throttled for a few seconds at a time. Spread out bulk operations instead of firing them all at once. - **Hourly caps per organization**: actions that send email to people outside your organization have hourly caps. By default, guest invites (including mentions of new email addresses in comments) allow 30 per hour, and comment posting allows 120 per hour, per organization. Hourly-cap responses include `code: "RATE_LIMIT_EXCEEDED"` in the JSON body: ```json { "message": "You've reached the hourly limit for Guest Invite (30 per hour per organization). Please try again later.", "code": "RATE_LIMIT_EXCEEDED" } ``` Wait the number of seconds given in `Retry-After`, then retry. If you're hitting limits regularly, implement caching or batching - and 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. **Read the API docs** - Browse the official [API reference](https://go.tallyfy.com/api/) for endpoint details. 3. **Check code examples** - See practical examples on [Tallyfy's GitHub repo](https://github.com/tallyfy/api-support/) in various programming languages. :::note[Testing API calls] Use tools like Postman, Insomnia, or `curl` to test API requests. ::: :::tip[Want a ready-made command line tool?] The [Tallyfy CLI](/products/pro/integrations/cli/) wraps this API for you - authentication, required headers, and retries are handled automatically. Launch processes, export templates, and script bulk jobs without writing any HTTP code. ::: ## Recommended next - [Integrate with Tallyfy using the API](/products/pro/integrations/open-api/how-to-integrate-with-tallyfy-using-api/) - detailed authentication and request examples. - [API usage as a third-party application](/products/pro/integrations/open-api/access-api-as-a-third-party-application-instead-of-a-user/) - client credentials flow for multi-user apps. - [API code samples](/products/pro/integrations/open-api/code-samples/) - practical examples in various programming languages. - **[Middleware](https://tallyfy.com/products/pro/integrations/middleware/)**: Tallyfy connects to thousands of business apps through middleware platforms like Zapier and Make.com. These drag-and-drop tools need no coding and let you launch processes from external events and sync data in minutes. ## Connect Tallyfy without coding Middleware platforms like Zapier, Make, and Power Automate connect Tallyfy to your other business apps - CRMs, spreadsheets, email tools, and more. They're visual tools that let you drag and drop connections between systems, with no coding required. You don't need to wait for IT or hire developers. 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 benefits does middleware provide with Tallyfy? | Benefit | Description | |------------------------|------------------------------------------------------------------| | **No coding required** | Connect apps without API knowledge or dev expertise | | **Fast setup** | Get connections running in minutes, not weeks | | **Low maintenance** | Middleware vendors maintain and update connections automatically | | **Visual design** | Build integrations with drag-and-drop interfaces | | **App library** | Access thousands of pre-built connectors to popular apps | | **Data transformation** | Convert data between Tallyfy's format and other apps | | **Error handling** | Built-in retry and error recovery for failed transfers | | **High volume** | Handle large transfers and multi-system integrations | ### Common use cases with Tallyfy #### 1. Launch Tallyfy processes from external apps - Start processes when events happen in other systems (e.g. a deal closes in your CRM). - Pre-fill kick-off form fields with data from the triggering app - no manual data entry. - Assign tasks based on information from external systems. #### 2. Push Tallyfy data to external systems - Send form responses to CRMs, ERPs, or spreadsheets. - Update external systems when processes hit milestones or complete. - Keep customer information synced across all your tools. #### 3. Coordinate multi-app workflows - Build workflows that span Tallyfy and multiple other apps. - Coordinate processes running across different platforms. - Eliminate manual data entry between systems. ### Which middleware platforms work with Tallyfy? Tallyfy works with live connectors for **Zapier**, **Microsoft Power Automate**, **n8n**, **Make**, and **Celigo**. The Make and Celigo connectors are built and maintained by those vendors (Make on its marketplace, Celigo inside integrator.io), so you can add them today. Only the dedicated **Workato** connector isn't published to its marketplace yet. #### Zapier :::note[Choosing a tool] Zapier works well for simple connections. For more complex workflows or higher volumes, consider **Microsoft Power Automate** or **n8n**. For full control, developers can use Tallyfy's [Open API](/products/pro/integrations/open-api/). ::: - **Good for**: Beginners, simple connections. - **Features**: Thousands of app connectors, easy visual editor. - **Downsides**: Less flexible for complex needs. - [**View Zapier guide →**](/products/pro/integrations/middleware/zapier/) #### Microsoft Power Automate - **Good for**: Companies already using Microsoft 365. - **Features**: Deep Microsoft app integration, desktop task automation. - **Downsides**: Best within the Microsoft suite. - [**View Power Automate guide →**](/products/pro/integrations/middleware/power-automate/) #### n8n - **Good for**: Teams wanting open-source flexibility and self-hosting. - **Features**: Self-hosting option, visual workflows, code-level flexibility. - **Downsides**: Requires more technical setup if self-hosting. - [**View n8n guide →**](/products/pro/integrations/middleware/n8n/) #### Make, Celigo, and Workato Make and Celigo both have official Tallyfy connectors built and maintained by those vendors, so you can add them today: Make from its marketplace, and Celigo inside integrator.io (it supports an API token or OAuth 2.0). The dedicated Workato connector is built but not yet published to its marketplace, so for now connect Workato using its HTTP module with [Tallyfy's REST API](/products/pro/integrations/open-api/); [Tallyfy support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/) can arrange early access. - [**View Make guide →**](/products/pro/integrations/middleware/make/) - [**View Celigo guide →**](/products/pro/integrations/middleware/celigo/) - [**View Workato guide →**](/products/pro/integrations/middleware/workato/) #### Tray.io - **Good for**: Complex, multi-step workflows with branching logic. - **Features**: Handles complex logic and branching well. - **Downsides**: More technical to use. ### Implementation steps 1. **Plan**: Identify what data needs to move between Tallyfy and your other apps - which direction and how often. 2. **Pick a platform**: Choose the middleware that matches your needs and technical skills. 3. **Design**: Map out your integration - what triggers it, how data transforms, and where it ends up. 4. **Build and test**: Create your connections and test thoroughly, including failure scenarios. 5. **Monitor**: Set up alerts so you'll know if something stops working. The following articles cover specific middleware tools in detail. - **[Robotics](https://tallyfy.com/products/pro/integrations/robotics/)**: Integrating robot systems with human workflows requires bridging proprietary control protocols like OPC UA and ROS2 through middleware and edge computing. Strict OT/IT network segregation and safety compliance are essential across manufacturing and logistics environments. ## Robotics workflow challenges Coordinating robot systems with human teams is hard. Industrial and commercial robots run on proprietary control systems and communication protocols - connecting them to business workflows requires middleware, protocol translation, and careful architecture planning. ## Common communication protocols ### OPC UA (Open Platform Communications Unified Architecture) Industry standard used by major manufacturers (ABB, KUKA, FANUC, Siemens). It provides secure machine-to-machine communication with built-in data modeling. ### ROS/ROS2 (Robot Operating System) Open-source robotics middleware common in research and collaborative robots. ROS2 uses DDS (Data Distribution Service) for real-time communication between nodes. ### MQTT (Message Queuing Telemetry Transport) Lightweight publish-subscribe protocol built for IoT devices. Used for robot telemetry and event-driven communication, with lower bandwidth needs than OPC UA. ### Proprietary protocols Many manufacturers use proprietary communication methods that need vendor-specific SDKs or edge devices to translate into standard protocols. ## Integration architecture ### Network topology Robot systems typically need network segregation between operational technology (OT) and information technology (IT) networks. Integration points usually happen through: - DMZ (demilitarized zone) with controlled access - Edge computing devices bridging OT and IT networks - API gateways with rate limiting and authentication - Message queues for asynchronous communication ### Security requirements When connecting robots to external systems, you'll need: - 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 drops - Air-gapped operation for safety-critical systems ## Human-robot collaboration workflows Modern industrial settings increasingly mix automated and manual work. Coordinating these workflows means connecting robot control systems with human task management. ### Common patterns **Assembly operations** - Robots handle heavy lifting and precise positioning while humans manage delicate components that need dexterity. **Quality inspection** - Automated measurement systems run initial checks, routing exceptions to human inspectors. **Maintenance workflows** - Diagnostic routines generate data that maintenance teams use for troubleshooting and repair. ### Safety and compliance Industrial robot deployments must follow relevant safety standards: - ISO 10218 (Safety requirements for industrial robots) - ISO/TS 15066 (Collaborative robots) - ANSI/RIA R15.06 (North American industrial robot safety) Audit trails help demonstrate compliance during safety assessments. ## Planning your integration ### Technical requirements - API access and authentication - Network connectivity and bandwidth - Protocol translation capabilities - Edge computing or middleware needs - Data sync and latency requirements ### Organizational readiness - IT and operations team collaboration - Clear ownership of robot systems - Change management processes - Training for maintenance staff - Incident response procedures ## Industry applications ### 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 ## Common challenges **Protocol complexity** - Translating between industrial protocols and business systems needs specialized middleware and expertise. **Network security** - Keeping proper OT/IT segregation while enabling data flow. **Latency sensitivity** - Real-time robot control and asynchronous workflow updates need 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 often struggle with: - Keeping operational procedures up to date - Sharing improvements across multiple robot installations - Tracking which procedures were followed for compliance - Managing procedure versions as operations evolve - Coordinating human and automated tasks ## Vendor resources Each vendor page below covers workflow management considerations for that robot platform: - **[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**: Implementation details depend on your organization's requirements, robot configurations, and network architecture. ## Important disclaimer **Information currency**: This documentation covers general robotics workflow integration concepts. 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 technical or business decisions: - Check current vendor capabilities through official documentation - Consult robot manufacturers for specific integration requirements - Review current safety standards and compliance obligations - Assess your organization's specific needs **No guarantees**: This documentation doesn't 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 robotics integration requirements and current capabilities. - **[Tallyfy Desktop AI surface](https://tallyfy.com/products/pro/integrations/tallyfy-desktop-ai/)**: Tallyfy Desktop v2.0.0 is a multi-tab AI-first app that pairs four AI assistants (Claude, Codex, Gemini, Ollama) with your Tallyfy workspace. Every AI run becomes a tracked task, the Tallyfy MCP server is auto-injected, and an inline widget turns chat into Tallyfy work. :::note[What this section covers] End-user docs for the AI surface in Tallyfy Desktop v2.0.0. If you want to know what each tab does, how to connect Claude, Codex, Gemini, or Ollama, what the Task Intent Widget does, and how Terminal Jobs tracks every run, you're in the right place. Internal architecture references (the `AIProvider` contract, IPC channels, the SQLite schema) stay in the desktop repo, which is private, under `docs/AI-ARCHITECTURE.md` and `docs/PROVIDER-MATRIX.md`. ::: ## What Tallyfy Desktop is Tallyfy Desktop is a cross-platform Electron app for macOS, Windows, and Linux. v1 of the app was a thin shell around the Tallyfy web client. v2.0.0 is a different product: an AI-first surface that hosts four AI assistants side-by-side in a tabbed window, with your Tallyfy workspace as the system of record. Think of it as a single window where you can talk to Claude in one tab, Gemini in another, and keep an eye on a long-running Ollama job in a third, while every conversation you have can create a Tallyfy task, launch a process, or edit a template with one click. ![Tallyfy Desktop showing four AI tabs and the Task Intent Widget inline in a chat bubble](https://screenshots.tallyfy.com/desktop-ai/overview-screenshot.png) ## What v2.0.0 brought in The AI Surface Pivot landed seven user-visible changes. Each is documented in its own article in this section. ### 1. Four provider tabs The window has a tab for each AI assistant Tallyfy Desktop supports: - **Claude** (Anthropic) - the most capable provider for tool use, thinking, and browser automation - **Codex** (OpenAI) - text streaming via the official `codex` CLI - **Gemini** (Google) - streaming chat with MCP support - **Ollama** (local) - your own models, running entirely on your machine Each tab is its own conversation. Switching tabs doesn't lose context. The tab strip shows which providers are installed and signed in, so you can tell at a glance which assistant is ready to use. Connect each one with its own short guide: - [Connect Claude](/products/pro/integrations/tallyfy-desktop-ai/connect-claude/) - [Connect Codex](/products/pro/integrations/tallyfy-desktop-ai/connect-codex/) - [Connect Gemini](/products/pro/integrations/tallyfy-desktop-ai/connect-gemini/) - [Connect Ollama](/products/pro/integrations/tallyfy-desktop-ai/connect-ollama/) ### 2. The Task Intent Widget The Task Intent Widget is the feature that turns chat into Tallyfy work. As you type with an AI, the desktop app watches for phrases like "create a task for John" or "let's run the onboarding process." When it spots an intent, it shows a one-click widget inline in the chat bubble that creates the task, launches the process, or edits the template in your Tallyfy account. Read the full [Task Intent Widget guide](/products/pro/integrations/tallyfy-desktop-ai/task-intent-widget/) for details on the four states, the per-intent prefill shapes, and how the two-stage detector keeps false positives down. ### 3. Mandatory Tallyfy sign-in You sign into your Tallyfy account before any AI tab is visible. The app shows a single "Sign in with Tallyfy" screen on first launch. After sign-in, the app stores your session token in the OS keychain (Keychain on macOS, Credential Manager on Windows, Secret Service on Linux when available). Why? Because everything else in the app, from MCP injection to task wrapping to the intent widget, needs your Tallyfy identity. Letting the AI surfaces run without a Tallyfy account would mean the AI doesn't know who you are, what org you're in, or where to put the tasks it creates. ### 4. Tallyfy MCP auto-injection Every AI chat in the desktop app gets the [Tallyfy MCP server](/products/pro/integrations/mcp-server/) auto-injected as its first MCP. You don't paste a URL into a config file. You don't run `claude mcp add`. The desktop app handles it behind the scenes using your Tallyfy session token. This means every AI tab knows about your tasks, processes, templates, members, and guests from the moment you open it. Ask Claude "what tasks do I have due this week?" and it answers without any setup. For Codex (no MCP support in v1) and Ollama (capability-degraded), the desktop app falls back to a system-prompt prefix that gives the AI the same Tallyfy context. ### 5. System "AI Runs" checklist Every AI run becomes a Tallyfy task in a system checklist called "AI Runs." This is the v2.0.0 invariant: nothing the AI does is invisible. The task records the provider, the model, the prompt, the cost (where available), and the deep link back to the desktop app. If something goes wrong, the task stays. It's marked with the error code so you can see what happened from your Tallyfy account, days or weeks later, on any device. The desktop app stores the raw run events locally; the Tallyfy task is the cross-device authority of record. ### 6. Local SQLite run history (Terminal Jobs tab) The Terminal Jobs tab is the desktop app's view of every AI run. It's a list, newest first, with status, duration, cost, and a button to view the full streamed output of any run. Read the [Terminal Jobs guide](/products/pro/integrations/tallyfy-desktop-ai/terminal-jobs/) for details. The data is stored in a local SQLite database on your machine. Run events never leave the device. The Tallyfy task row is the only cloud artifact, and it carries only the metadata you'd see in any other Tallyfy task. ### 7. Auto-installer The first time you click on a provider tab whose CLI isn't installed, the desktop app shows an Install Wizard. It explains exactly what command will run, lists the risks (network egress, disk writes, service registration), and waits for you to hold the Shift key for three seconds before installing. After install, it verifies the binary works and reports back. The install commands are baked into the app source code (not fetched at runtime), so what you consent to is what runs. The exact commands per provider are listed in each provider's connect guide. ## Subscription-only AI Tallyfy Desktop v2.0.0 does not accept API keys. You connect via your existing AI subscription: - **Claude** uses OAuth via your Claude.ai account (Pro, Max, Team, or Enterprise plan) - **Codex** uses OAuth via your ChatGPT account (Plus, Pro, Team, Enterprise, or Edu plan) - **Gemini** uses OAuth via your Google account - **Ollama** runs locally on your machine; no account, no subscription This is a deliberate design decision. API keys are long-lived secrets that easily leak; OAuth tokens are short-lived and scoped. The desktop app handles the OAuth flow for each provider through its official CLI, so you keep one billing relationship per provider and Tallyfy never sees your AI costs. ## Privacy and data flow What the desktop app does with your data: 1. Prompts you type go to the AI provider you selected. No interception. No copy. 2. Streamed responses come back from the provider, render in the chat window, and are recorded in the local SQLite database. 3. Run metadata (provider, model, prompt summary, cost, duration) is sent to Tallyfy as a task in the "AI Runs" checklist. 4. Tallyfy state the AI reads or writes (tasks, processes, templates) goes through the Tallyfy MCP server and is logged in your existing Tallyfy audit trail. Ollama is the local case: everything stays on your machine. No prompts leave the device. The Tallyfy task is still created (because the run is still tracked), but the AI half of the conversation never touches a cloud. ## First launch: OS security prompts (v2.0.0) v2.0.0 is not yet code-signed. The first time you open it, your operating system will warn you. This is expected. Here is what you will see and what to do. ### macOS Double-clicking the app the first time shows: "Tallyfy cannot be opened because Apple cannot check it for malicious software." Click Cancel, then **right-click (or Control-click) the Tallyfy app and choose Open** from the menu. macOS shows a second prompt with an Open button. Click Open. After this one-time approval, you can launch normally. Apple Silicon Macs are stricter than Intel and always need this right-click path on first launch. ### Windows Running the installer the first time shows: "Windows protected your PC. Microsoft Defender SmartScreen prevented an unrecognized app from starting." Click **More info** (the small link), then **Run anyway**. SmartScreen eases up after the binary builds reputation across enough machines. ### Linux `.AppImage` and `.deb` install without OS security prompts. If the AppImage will not run, mark it executable: `chmod +x Tallyfy-2.0.0.AppImage`. Signed releases (which install silently) land in a future v2.0.x once we provision the certificate. Auto-update inside the app handles subsequent versions without prompts. ## What's next in this section | Article | What it covers | |---|---| | [Connect Claude](/products/pro/integrations/tallyfy-desktop-ai/connect-claude/) | Install the Claude CLI, sign in with OAuth, verify the connection | | [Connect Codex](/products/pro/integrations/tallyfy-desktop-ai/connect-codex/) | Install Codex via npm, sign in with `codex login`, verify | | [Connect Gemini](/products/pro/integrations/tallyfy-desktop-ai/connect-gemini/) | Install the Gemini CLI via npm, complete the OAuth flow, verify | | [Connect Ollama](/products/pro/integrations/tallyfy-desktop-ai/connect-ollama/) | Install Ollama locally, pull a model, verify the daemon | | [Task Intent Widget](/products/pro/integrations/tallyfy-desktop-ai/task-intent-widget/) | What the widget does, when it shows, how to use it | | [Terminal Jobs](/products/pro/integrations/tallyfy-desktop-ai/terminal-jobs/) | Track every AI run, view output, cancel running jobs | - **[Vendors](https://tallyfy.com/products/pro/integrations/vendors/)**: Tallyfy acts as a coordination layer that connects your existing HR, CRM, helpdesk, finance and RPA platforms by managing the cross-department handoffs and multi-team workflows that no single vendor tool can handle on its own. ## The coordination layer your vendors need Your HR, Finance, and collaboration platforms are great at their core functions. But they can't coordinate cross-department processes. When someone's 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 coordinating workflows across ALL your teams, not just within one vendor's world. ## 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 teams - Escalate when actions are delayed ## Available vendor connections ## The gap Tallyfy fills **CRM systems** track deals through pipeline stages but can't coordinate micro-tasks between stages - proposal development, technical scoping, pricing approvals, contract reviews, and post-sale handoffs. **Helpdesk tools** capture tickets and conversations but can't turn unstructured requests into structured process funnels with clear accountability and deadlines. **HR systems** manage employee data but can't coordinate IT provisioning, Facilities setup, or Training schedules when someone joins or leaves. **Finance systems** process transactions but can't handle multi-party approvals, month-end close coordination, or reconciliation workflows. **Communication tools** enable conversations but can't ensure accountability, track action items, or enforce deadlines. **RPA platforms** automate repetitive screen tasks but can't coordinate the human activities before, during, and after bot execution. Exception handling, approvals, and bot-human handoffs all need coordination. Tallyfy works WITH these vendors as the coordination layer for processes spanning multiple teams and systems. ## CRM coordination CRM platforms are great at tracking deals and customer relationships. But deals need more than tracking - they need coordinated tasks across multiple teams that CRMs can't handle. **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 coordination Helpdesk platforms capture support tickets and conversations. But complex issues need more than replies - they need structured workflows that turn 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 coordination RPA platforms like UiPath, Automation Anywhere, and Blue Prism are great at automating repetitive, rule-based tasks. But most processes need BOTH automated AND human activities. Tallyfy provides the coordination 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 - Full process visibility - Accountability for 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 integration - [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 structured JSON data to any external system via HTTP POST requests whenever workflow events like task completions or process launches occur, eliminating the need for constant polling and enabling instant real-time integrations with middleware platforms or custom APIs and serverless functions. ## What are Tallyfy webhooks and how do they work? Webhooks send structured JSON messages from Tallyfy to external systems whenever specific events happen in your workflows. They're automatic - no polling required. When a task gets completed, a process launches, or a status changes, Tallyfy fires an HTTP POST request to a URL you specify. The receiving system gets the data instantly and can act on it. :::tip[Webhooks = Automatic doorbell] Think of a webhook like an **automatic doorbell** for your other software: - 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. No constant checking needed - the notification comes to you. ::: Any system that can receive HTTP POST requests can receive Tallyfy webhooks. ### Key benefits - **Instant data delivery** - Get event details the moment something happens in a Tallyfy workflow. - **Standard JSON format** - Works with any system that understands JSON. - **Universal compatibility** - Any HTTP-capable system can be a webhook destination. - **Automatic triggers** - Start workflows or actions in external systems based on specific Tallyfy events, with no manual steps. ### Where can you send Tallyfy webhooks? Webhooks can go to several types of destinations: - **Middleware platforms** (Zapier, Make, Power Automate) - route data to other apps without coding. - **Custom APIs and applications** - your own endpoints built for specific business logic. - **Serverless functions** (AWS Lambda, Azure Functions) - event-driven processing without managing servers. - **RPA bots** (Robotic Process Automation) - automate actions in legacy systems that don't have modern APIs. :::note[Choosing how to use webhooks] Sending webhooks to middleware (Zapier, Make, etc.) is the easiest way to connect Tallyfy events to other apps without coding. Building your own webhook receiver gives you more control but requires development resources. ::: :::note[Considering integration alternatives] While Zapier works for simple connections, we generally recommend more capable and cost-effective middleware like **n8n**, **Make**, or **Microsoft Power Automate** for serious integrations. For maximum control, 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/)**: Many countries require workplace documents like contracts and SOPs in local languages. Tallyfy uses Azure AI-powered translation to render workflow content into 100+ languages, helping global organizations stay compliant across jurisdictions. ## Where do laws exist to translate process content to local languages? **Important** - this article is not legal advice. You need to do your own research and use this content at your own risk. Some countries fine you for English-only workplace documents. Others just recommend translations. This reference maps out which jurisdictions require workplace content in local languages - and which ones are fine with English only. Organizations using 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 that different countries regulate: - **Employment contracts and agreements** - **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** ## 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 Official Languages Act mandates bilingual English and French communication in federal institutions. Federal employees in designated bilingual regions can work and receive documents in their official language of choice. Private-sector workplaces outside Quebec have no translation requirements. [2] ### Canada - Quebec **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 - offers, contracts, policies, and training materials - must be in French unless an employee specifically requests another language. Pre-existing English documents had to be translated by June 1, 2023. This 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 translation requirement for private employers' internal documents. [2] ### United States (federal) **Requirement level:** Mandatory for safety/rights 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 requires safety training and hazard communications in comprehensible language. 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 SS2810.5 requires new-hire wage/hour notices in "the language the employer normally uses to communicate employment-related information." California and New York mandate certain posters or notices in Spanish and other languages if threshold percentages of workers aren't English-proficient. 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 must be in Spanish to be legally valid, with Spanish prevailing in legal effect. Documents submitted to labor authorities or courts must be in Spanish or accompanied by official translation. Many companies provide bilingual Spanish-English contracts, 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. [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 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. [12] ## Europe ### France **Requirement level:** Mandatory (French required 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 instructions to be in French. This covers 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 strict - employers have been fined for issuing English-only handbooks. 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:** Regional language laws require all employment documents and communications in the Flemish region be in Dutch. Documents in another language are null and void against the employer. Employees can 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. 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). Employers in Brussels often provide documents in both languages. Unlike Flanders/Wallonia, the sanction for using the 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 statutory requirement regarding employment document language. Contracts and policies are usually in official languages (French, German, or Luxembourgish) or English - as long as both parties understand the language used. 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, courts hold that employees must comprehend workplace rules - key instructions (safety, disciplinary rules) should be explained in German if workers aren't fluent. Translation is recommended as best practice but not legally required in the 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. However, if workers don't understand a document's language, employers must provide explanation or translation. 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; bilingual as needed) **Applies to:** Private and public sectors **Requirements:** Spanish labor law requires employment contracts be in Spanish (Castilian). Bilingual contracts (Spanish-English) are allowed, but Spanish text governs in case of conflict. Handbooks and safety instructions should also be in Spanish for full effectiveness. In 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 for private companies. Contracts may be in a foreign language if both parties understand it. However, all legal proceedings are in Italian, so providing Italian translations when employing local staff is strongly recommended. Courts may favor Italian text interpretation or require certified translation of foreign-language documents. [8] ### Poland **Requirement level:** Mandatory (Polish required; bilingual allowed) **Applies to:** Private and public sectors **Requirements:** The Polish Language Act (amended 2011) requires employment documents be in Polish to be binding. Employment contracts, agreements, and internal work regulations must be in Polish (bilingual versions are allowed). Polish text prevails in case of discrepancies. Employees may request documents in another language in addition to Polish, but Polish remains the legal reference. [9] ### Czech Republic **Requirement level:** No specific law (Czech used customarily) **Applies to:** Private and public sectors **Requirements:** No law requires Czech for employment documents. The Labor Code allows agreements in other languages if both parties agree and understand them. In practice, most contracts with local staff are in Czech. Providing documents in Czech is highly recommended since court or authority proceedings require Czech versions. [8] ### Hungary **Requirement level:** No specific law (use Hungarian for clarity) **Applies to:** Private and public sectors **Requirements:** Hungarian law doesn't mandate Hungarian in employment contracts or policies. Employers and employees can choose another language if mutually understood. However, authorities and courts require Hungarian translations in official processes. 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, employment contracts must be in Romanian (even if foreign language versions are also provided). 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 often use bilingual formats. [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. Internal communications related to employees' rights and safety must also be in Slovene. This is strictly enforced - documents not in Slovenian could be deemed non-compliant. [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. Virtually all employment contracts and workplace policies are in German. English contracts aren't invalid if employees fully understand them, but filings with authorities must be in German. 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) or English if employees agree. **Nordic countries (Sweden, Norway, Denmark, Finland):** No legal mandates to use local language in contracts, but documents are generally in the local language for native employees. Finland explicitly states employees must be briefed in a comprehensible language. **United Kingdom/Ireland:** No requirement to translate policies (English is working language). Providing translations for immigrant workers is considered good practice for health and safety reasons. **Eastern Europe (Baltics, Balkans not listed above):** Official language is required for official filings and strongly recommended for contracts, but not always explicitly mandated by statute. [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. Employment contracts should be executed in Chinese for legal certainty - Chinese language contracts are required if disputes go to courts or documents are submitted to government agencies. Companies often sign bilingual Chinese-English contracts, but the Chinese version prevails legally. Internal regulations and manuals should be in Chinese or translated. [13] ### Japan **Requirement level:** No explicit requirement (Japanese strongly recommended) **Applies to:** Private and public sectors (public sector uses Japanese by law) **Requirements:** No specific law forces Japanese use in private employment contracts or policies. However, labor disputes are handled in Japanese, so it's standard practice to provide employment terms in Japanese. Government guidance encourages that non-Japanese workers be given contracts in a language they understand. Foreign companies operating in Japan often prepare bilingual documents (Japanese and English). [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 the private sector, but Korean is the normal working language. 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. [12] ### India **Requirement level:** No nationwide requirement (state laws on notices in local languages) **Applies to:** Private and public sectors (state-specific) **Requirements:** India has no single official language nationally (the constitution recognizes Hindi and English). English is commonly used for contracts and policies in private companies. However, many states require certain notices (standing orders, factory safety instructions) be displayed in the local regional language (Hindi, Bengali, Tamil, etc.). Employers must ensure all employees comprehend workplace rules - which often means providing translations in local language for blue-collar workers. Government forms use Hindi or the 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. English is the de facto language of business. For safety training, employers must ensure communication is effective, which may involve translation or interpreters if language barriers exist. Some large employers translate key policies into languages like Chinese or Arabic as best practice, but providing documents in English is sufficient under Australian law. [12] ### New Zealand **Requirement level:** No requirement **Applies to:** Private and public sectors **Requirements:** No requirement to translate employment documents. English (and Maori in some public contexts) is used for contracts and workplace policies. 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. [12] ### Indonesia **Requirement level:** Mandatory (Indonesian required; bilingual allowed) **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. Employment contracts with Indonesian employees must have an Indonesian version. If a foreign party is involved, the contract may be bilingual (Indonesian and English), but Indonesian text is authoritative. Indonesia's Supreme Court has said absence of an Indonesian version won't automatically void a contract if no bad faith is involved - but employers should comply and issue Indonesian-language contracts. Company regulations must also be in Indonesian. [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 and legally acceptable, as is Malay (Bahasa Malaysia). In public sector and official dealings, Malay is the official language. Many firms use dual-language (Malay/English) contracts. Safety-related communications 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. No legal requirement to translate employment materials - English contracts and handbooks are the norm. The government publishes some mandatory notices in multiple languages, and employers are encouraged to communicate in a language workers understand (especially in construction/domestic work sectors). Legally, an English document suffices. [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; internal labor regulations must also be in Vietnamese. **Thailand:** Thai labor law expects employment agreements to be in Thai if with Thai staff; Thai versions are needed for official filings or disputes. For most other Asian countries not listed, the general pattern is that official national language should be used for employment communications, but specific translation mandates are uncommon. [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. In practice, contracts are typically bilingual Arabic-English, but Arabic text is the legally binding version. All filings with the Ministry of Human Resources must be in Arabic. Workplace policies can be provided in English as well, but an Arabic version is needed for 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 (contracts, disciplinary rules, etc.) shall be in Arabic. Companies often have dual-language contracts (Arabic/English), but Arabic prevails legally. Any policy not in Arabic may not be recognized by authorities. For foreign workers who don't speak Arabic, an interpreter or translated copy is typically provided (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. No specific labor law forces translation of documents, but employers must inform employees of employment terms in a language they understand (a principle under case law). Hebrew contracts and policies are standard. For employees who aren't Hebrew-proficient, providing Arabic or English versions is best practice. 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. No statute requires translation of employment documents. Employers typically use English for contracts and policies. However, the Constitution requires that procedures like disciplinary hearings be explained in a language the employee understands (interpreters provided if needed). Written documents can be in English by default without violating any law. [12] ### Kenya / Nigeria (example) **Requirement level:** No specific requirements (use official language in documentation) **Applies to:** Private and public sectors **Requirements:** These nations use English as an official language (alongside local languages). No specific labor laws compel translation 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 practice rather than legal mandate. French-speaking African countries (Senegal, Cote d'Ivoire) similarly use French for all employment matters. [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 (Egypt's labor law mandates Arabic contracts; Morocco requires French or Arabic for certain notices). **Francophone Africa:** French is the default language for employment documentation (Ivory Coast, Cameroon). **East Africa:** English (and Swahili in Tanzania/Kenya) serves as the working language; no special translation laws. Employers in these regions should use the official language(s) for written documents to ensure enforceability. Where employees speak minority languages, translations are a matter of policy 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/) automatically translates workflow content into 100+ languages. Here's what that means in practice: - **Maintain compliance** with local language laws - process templates and step instructions automatically appear in the right language - **Ensure employee comprehension** of safety procedures across multilingual teams - **Reduce translation costs** - real-time translation replaces manual document translation - **Scale globally** without juggling dozens of template versions in different languages - **Adapt quickly** when regulations change - update once, and it translates everywhere 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? Here's the strategic playbook based on the requirements above: 1. **Identify mandatory vs. recommended jurisdictions** - countries like France, Belgium, Quebec, UAE, and Saudi Arabia enforce their language laws actively. 2. **Establish authoritative language versions** - most places let you go bilingual, but they're clear about which version wins in court. 3. **Ensure employee comprehension** - even if the law doesn't require it, making sure workers understand safety procedures in their language is good practice. 4. **Plan for enforcement variation** - France and Belgium enforce strictly. 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). - **[Azure Cognitive AI integration setup](https://tallyfy.com/products/pro/integrations/azure-translation/how-to-set-up-azure-cognitive-ai-integration/)**: Tallyfy integrates with Microsoft Azure Translator for real-time translation of task descriptions, comments, and form data. Connect your Azure API key, resource name, and region through admin settings in about 15 minutes. ## Connecting Azure Translator to Tallyfy Tallyfy uses Microsoft Azure Translator to translate user-generated content - task descriptions, comments, form data - into your preferred language in real time. Setup takes about 15 minutes and requires three pieces of information from Azure: an API key, your resource name, and the region. ### What you'll need - Administrator access to your Tallyfy organization - An Azure account (or permission to create one) - Permission to create Azure Translator resources ### Step 1: Azure account setup If you don't already have an Azure account: ### Step 2: Create a Translator resource ### Step 3: Configure your Translator resource Deployment takes 1-3 minutes. Click **Go to resource** when it's done. ### Step 4: Copy your API key The **Keys and Endpoint** page also shows a **Location/Region** value. That's the same region you'll enter in Tallyfy, so copy it now while you're here. You now have the three values Tallyfy needs: the **API key**, the **resource name** (what you named your Translator resource), and the **region** you selected during creation. ### Step 5: Configure Tallyfy Tallyfy automatically tests your credentials before saving. If the test fails, you'll see an error message - double-check each field. ![Tallyfy Azure translation integration settings screen](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-azure-integration-setup.png) ### Step 6: Verify translation works ### Managing costs Azure charges by the character. The free tier covers 2 million characters monthly - roughly 400,000 words. Monitor usage in the Azure portal under your Translator resource, and set up spending alerts if you want to avoid surprises. ### Troubleshooting Translation not working? Here's what to check: - **Credentials** - verify you entered the correct API key, resource name, and region (all three are required) - **Key status** - Azure keys can be regenerated, which invalidates the old one - **Quota** - check your Azure subscription hasn't exceeded its character limit - **Network** - confirm your environment can reach Azure services (firewalls or security policies may block the connection) - **Language pairs** - translation quality varies by language combination, and specialized industry terms may not translate perfectly - **[Content translation](https://tallyfy.com/products/pro/integrations/azure-translation/how-to-use-content-translation/)**: Tallyfy's content translation uses Microsoft Azure AI to translate text like descriptions, comments, and form answers in real-time. Each team member reads content in their preferred language from 100+ options. ## Use content translation in Tallyfy *(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.)* Tallyfy's content translation automatically translates user-generated text in real-time using Microsoft Azure AI. Each team member reads content in their preferred language, across 100+ supported languages. It's separate from the [UI language setting](/products/pro/integrations/azure-translation/), which controls buttons and menus. Content translation handles the text your team actually writes: descriptions, comments, and form field answers. ### What gets translated Content translation covers visible text that you and your team create: - Descriptions and instructions in templates and tasks. - Information entered into form fields. - Comments added to tasks or processes. ### What stays in the original language - Tallyfy's interface elements. Use the separate [UI language setting](/products/pro/integrations/azure-translation/) for those. - Standard system messages. - Form field labels (but the answers *in* those fields do get translated). ## How to set up your content language Once your organization has the Azure AI connection configured, you'll see a globe icon in Tallyfy's top menu bar. The globe animates when translation is actively processing. ### Where translations appear - **In templates**: Descriptions and instructions display in your chosen language. - **In tasks**: Instructions, comments, and form field answers show up translated. Text you enter is saved in your language but appears translated to others based on *their* preference. - **In reports**: Text descriptions get translated. Numbers, charts, and fixed labels don't change. ### Tips for better translations - Write original text clearly and keep sentences short. - Avoid slang, jargon, or culturally specific phrases. - Have a native speaker review important translated content when possible. ### Switching languages To turn off translation, select **No Translation** from the content language dropdown. ### How it works for multilingual teams - Each person picks their preferred reading language independently. - Everyone sees the same information, just translated for them. - Comments or form answers typed in one language appear translated automatically for users with a different language preference. - Numbers and dates stay consistent across all languages. ### Authentication - **[Domain verification](https://tallyfy.com/products/pro/integrations/authentication/domain-verification/)**: Verify ownership of your organization's email domains in Tallyfy by adding a DNS TXT record. A verified domain is the precondition for safe just-in-time auto-join and for SSO-only enforcement, so strangers whose own IdP asserts your domain can't be added to your org. ## Prove you own your email domain Domain verification tells Tallyfy that an email domain like `acme.com` really belongs to your organization. You prove it by adding one DNS TXT record. Once a domain is verified, Tallyfy can safely auto-join new people from that domain and let you enforce SSO-only login. You do all of this yourself under **Settings > Organization > Security > Domains**, on any paid plan. Why it matters: SSO assertions carry an email address, but an email address alone isn't proof. Any identity provider can technically assert any email. A verified domain is the check that stops someone whose own IdP claims an `@acme.com` address from being auto-added to your Acme org. ### What a verified domain turns on A domain stays unverified until you publish the TXT record. Verifying it turns on two things: | Feature | What verification enables | |---------|---------------------------| | **Auto-join (JIT)** | New users whose email is on a verified domain get a Tallyfy account created automatically on first SSO login (when auto-join is on). | | **SSO-only enforcement** | The **Require SSO** switch stays disabled until you have a verified domain, because enforcement without proof of ownership is unsafe. | Plain SSO login works without a verified domain. You only need verification for auto-join and enforcement. ### Add and verify a domain You'll need access to your domain's DNS settings (or someone on your team who has it). The record is a standard TXT entry, the same kind you'd add for email or other service verifications. DNS changes can take a few minutes to propagate, sometimes longer. If the first verify attempt fails, wait a bit and try again. The token stays valid, so you don't need to start over. ### After verification Once the badge shows verified, you can keep the TXT record in place. Tallyfy may re-check ownership over time, so removing the record later can un-verify the domain. Add every domain your team uses for email. If people sign in from both `acme.com` and `acme.co.uk`, verify both so auto-join and enforcement cover everyone. :::note[Verified domains and guests] Verified domains also support existing behavior like converting same-domain guests into members. Verifying a domain doesn't change who's already in your org. It only controls how new SSO users are handled going forward. ::: ### Troubleshooting Verification not passing? Check these: - The TXT record name and value match exactly what Tallyfy shows. A trailing space or a missing character will fail. - You added a **TXT** record, not a CNAME or A record. - You're verifying the bare domain (`acme.com`), not a subdomain or an email address. - Enough time has passed for DNS to propagate. Try again after a few minutes. - You can confirm the record is live with a public DNS lookup tool before clicking Verify again. - **[Integrate Microsoft Entra ID SSO](https://tallyfy.com/products/pro/integrations/authentication/how-to-integrate-azure-ad-samlsso-with-tallyfy/)**: Tallyfy integrates with Microsoft Entra ID (formerly Azure Active Directory) for self-serve SAML single sign-on. An admin creates an enterprise app in Entra ID, then pastes the metadata into the SSO wizard under Settings to enable automatic login. Entra provisioning adds SCIM directory sync. ## Connect Microsoft Entra ID for single sign-on Connect Microsoft Entra ID (formerly Azure Active Directory) to Tallyfy in about 30 minutes. Your users get automatic login and account creation - no separate passwords needed. :::note[You set this up yourself] SSO is self-serve. You configure both sides: create the enterprise app in Entra ID, then paste the Entra metadata into Tallyfy under **Settings > Organization > Security > SSO**. No support ticket needed. ::: ### Requirements - Microsoft Entra ID administrator access - A Tallyfy administrator account on any paid plan - The Tallyfy SP values from the SSO wizard (shown when you pick Microsoft Entra ID) ### What you'll do 1. Create a Microsoft Entra ID enterprise application 2. Configure SAML settings in both systems 3. Test the connection ## How SSO setup works You configure both Microsoft Entra ID and Tallyfy yourself. The Tallyfy SSO wizard is where you copy the SP values out and paste the Entra metadata back in. [Diagram removed for brevity] **Key points:** - Steps 1-7 are the one-time self-serve setup you run yourself across Tallyfy and Entra ID - Steps 8-12 happen every time someone logs in - No support ticket is needed to turn SSO on ### Phase 1: Create enterprise application #### Access enterprise applications #### Define application properties #### Assign users (optional) Assign users now or after setup - your choice: ![User assignment screen in Microsoft Entra ID](https://screenshots.tallyfy.com/azuresso-3.png) ### Phase 2: Configure SAML settings #### Access SAML configuration #### Configure basic SAML settings #### Configure user attributes These must be exact - wrong names or capitalization will break user sync. Your final attribute config should look like this: ![Completed user attributes and claims configuration](https://screenshots.tallyfy.com/azuresso-11.png) ### Phase 3: Complete the integration #### Get Microsoft Entra ID SAML information You need your Entra metadata. The simplest path is the metadata URL: #### Paste the metadata into Tallyfy Back in the Tallyfy SSO wizard (**Settings > Organization > Security > SSO**), move to the **Enter IdP details** step: #### Test and enable ### User access When users visit this URL: - Existing Tallyfy users log in automatically - New users from a verified domain get an account created on first login when auto-join is on. Verify your domain under the **Domains** tab first. See [Domain verification](/products/pro/integrations/authentication/domain-verification/). ### Troubleshooting Users can't log in? Check these: ### Set up SCIM provisioning (optional) SAML signs people in. SCIM keeps your directory in sync. With Entra provisioning on, Entra ID pushes user assignments and removals to Tallyfy automatically, so accounts track your directory and you stop paying for people who've left. To map Entra groups to Tallyfy roles, provision groups whose names match Tallyfy's reserved group names (for example `tallyfy-admins`). Full details are in [SCIM provisioning](/products/pro/integrations/authentication/scim-provisioning/). :::note[Advanced integration] Microsoft Entra ID's OAuth 2.0 and On-Behalf-Of token exchange work with AI systems. Microsoft unified its identity products under the Entra brand, improving multicloud support. Learn about [enterprise SSO patterns with MCP servers](/products/pro/integrations/mcp-server/sso-authentication/) to extend your Entra ID identity management to AI-powered workflow automation. ::: - **[Integrate Google Workspace](https://tallyfy.com/products/pro/integrations/authentication/how-to-integrate-google-suite-samlsso-with-tallyfy/)**: Connect Google Workspace with Tallyfy through self-serve SAML Single Sign-On by creating a custom SAML app in Google Admin, then pasting its metadata into the SSO wizard under Settings. Users authenticate with Google credentials, and new accounts are created on first login from a verified domain. ## Google Workspace SAML/SSO integration Connect Google Workspace (formerly G Suite) with Tallyfy using SAML-based Single Sign-On. Your users authenticate with their Google credentials - no separate Tallyfy passwords needed. :::note[You set this up yourself] SSO is self-serve. You configure both sides: create the custom SAML app in Google, then paste its metadata into Tallyfy under **Settings > Organization > Security > SSO**. No support ticket needed. ::: ### Requirements - Google Workspace admin account with super-administrator privileges - A Tallyfy administrator account on any paid plan - The Tallyfy SP values from the SSO wizard (shown when you pick Google Workspace) ### Phase 1 - Create a custom SAML app in Google Workspace #### Step 1: Create a custom SAML application #### Step 2: Configure basic app settings #### Step 3: Collect Google identity provider details #### Step 4: Configure service provider details Get the Tallyfy SP values from the wizard first: in Tallyfy, go to **Settings > Organization > Security > SSO**, start a new connection, pick **Google Workspace**, and copy the **SP ACS URL** and **SP Entity ID** it shows. Then, back in Google: #### 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 - Enter your Google details in Tallyfy Back in the Tallyfy SSO wizard (**Settings > Organization > Security > SSO**), move to the **Enter IdP details** step and provide the Google details you collected in Step 3. Google Workspace doesn't publish a fetchable per-app metadata URL, so use XML paste or manual entry here. ### Phase 3 - Test and enable in Tallyfy ### User provisioning and access After you finish the integration: ### How the authentication flow works Here's the full SAML authentication flow after configuration is done. [Diagram removed for brevity] **Key points:** - **Automatic provisioning** - New users from a verified domain are created on first login (step 9a) when auto-join is on. No manual account setup needed. - **Attribute mapping** - The email, FirstName, and LastName attributes from step 7 control how accounts are created and matched. - **Single authentication point** - Users only authenticate with Google (steps 4-5), never entering Tallyfy passwords. ### Troubleshooting Running into authentication problems? Check these: - Has the user been granted access to the SAML app in Google Workspace? - Are the attribute mappings correct? Double-check the table above - case matters. - Is the user accessing Tallyfy through the right SSO URL? - Still stuck? Contact Tallyfy Support. ### Directory sync with Google Workspace Google Workspace doesn't push SCIM to custom SAML apps the way Okta, Microsoft Entra ID, and OneLogin do, so there's no SCIM connector to wire up on the Google side here. For Google, the practical pattern is verified-domain auto-join: any Google user on a [verified domain](/products/pro/integrations/authentication/domain-verification/) gets a Tallyfy account on first SSO login. If you want full directory sync (automatic deactivation and group-to-role mapping) and you also run Okta or Entra, configure [SCIM provisioning](/products/pro/integrations/authentication/scim-provisioning/) through that provider instead. - **[Integrate JumpCloud SSO](https://tallyfy.com/products/pro/integrations/authentication/how-to-integrate-jumpcloud-samlsso-with-tallyfy/)**: Set up SAML-based SSO between JumpCloud and Tallyfy yourself by creating a custom SAML app, then pasting the JumpCloud metadata into the self-serve SSO wizard under Settings. Enables automatic login and just-in-time account creation for assigned users, with optional SCIM directory sync. ## JumpCloud SAML/SSO integration Connect JumpCloud with Tallyfy using SAML-based SSO for automatic user login and account creation. Setup takes about 30 minutes. :::note[You set this up yourself] SSO is self-serve. You configure both sides: create the SAML app in JumpCloud, then paste the JumpCloud metadata into Tallyfy under **Settings > Organization > Security > SSO**. No support ticket needed. ::: ### Requirements - JumpCloud administrator account - JumpCloud SSO Package or higher (or SSO add-on) - A Tallyfy administrator account on any paid plan - The Tallyfy SP values from the SSO wizard (shown when you pick JumpCloud) ### What you'll do 1. Create a custom SAML application in JumpCloud 2. Configure service provider settings and attribute mappings 3. Paste the JumpCloud metadata into the Tallyfy SSO wizard, test, and enable ### Phase 1 - Create JumpCloud SAML application #### Step 1 - Access SSO applications #### Step 2 - Configure general info The **Display Label** is what your users see on their JumpCloud dashboard, so keep it recognizable. ### Phase 2 - Configure SAML settings #### Step 1 - Get Tallyfy SAML values Tallyfy's service provider configuration tells JumpCloud where to send authentication data. You'll find these values in the Tallyfy SSO wizard. #### Step 2 - Enter service provider details in JumpCloud #### Step 3 - Configure attribute statements JumpCloud needs to know which user info to send to Tallyfy. Add these three attributes: These names are case-sensitive. Your mappings should look like this: | Service Provider Attribute | JumpCloud Attribute | |----------------------------|---------------------| | email | email | | FirstName | firstname | | LastName | lastname | ### Phase 3 - Configure Tallyfy with JumpCloud info #### Step 1 - Get JumpCloud SAML metadata #### Step 2 - Paste the metadata into Tallyfy and test Back in the Tallyfy SSO wizard (**Settings > Organization > Security > SSO**): JumpCloud doesn't publish a fetchable metadata URL per app, so use XML paste or manual entry here. #### Step 3 - Activate and assign users Nobody can sign in through JumpCloud until the application is Active *and* they're in one of the assigned groups. Both are needed. ### User provisioning and access Once everything's configured: What happens at login: - **Existing Tallyfy account** - they're logged in automatically with JumpCloud credentials - **No account yet** - if auto-join is on and the user's email is on a verified domain, Tallyfy creates an account on first login using the email, first name, and last name from JumpCloud. Verify your domain first under the **Domains** tab. See [Domain verification](/products/pro/integrations/authentication/domain-verification/). ### SSO authentication flow [Diagram removed for brevity] - Steps 1-9 are the one-time self-serve setup you run yourself across Tallyfy and JumpCloud - Steps 10-16 happen every time a user logs in - Tallyfy auto-creates accounts for new users from a verified domain (step 15) using email and name attributes from JumpCloud ### Troubleshooting Can't log in? Check these first: - Is the user assigned to the JumpCloud application? - Are attribute mappings exact? Names are case-sensitive - `FirstName` not `firstname` - Is the X.509 certificate still valid in JumpCloud? - Are users going to the SSO URL or JumpCloud portal - not the regular Tallyfy login page? - Is the application set to **Active** in JumpCloud? - Still stuck? Contact Tallyfy Support. ### JumpCloud-specific notes **Certificate management** - JumpCloud auto-generates and manages certificates when you activate an application. Monitor expiration dates in the JumpCloud Admin Portal. **User portal access** - Users can access Tallyfy through their JumpCloud portal alongside other apps. **Just-in-time provisioning** - User accounts in Tallyfy are created automatically on first SSO login from a verified domain. SCIM is optional but recommended for larger teams (see below). **Group-based access** - Control Tallyfy access by assigning JumpCloud user groups rather than individual users. ### Set up SCIM provisioning (optional) SAML logs people in. SCIM keeps your roster in sync. With SCIM on, JumpCloud pushes user adds, updates, and deactivations to Tallyfy automatically, so you don't rely on someone logging in first and you don't pay for people who've left. To map JumpCloud groups to Tallyfy roles, name the groups to match Tallyfy's reserved group names (for example `tallyfy-admins`). Full details are in [SCIM provisioning](/products/pro/integrations/authentication/scim-provisioning/). :::note[SSO with AI tools] Want to extend JumpCloud identity management to AI-powered workflow tools? Check out [SSO patterns with MCP servers](/products/pro/integrations/mcp-server/sso-authentication/) for more. ::: - **[Integrate Okta SSO](https://tallyfy.com/products/pro/integrations/authentication/how-to-integrate-okta-samlsso-with-tallyfy/)**: Tallyfy integrates with Okta through SAML 2.0 SSO that you set up yourself. Create an Okta SAML app, then paste the Okta metadata into the self-serve SSO wizard under Settings so users authenticate automatically. Add the Okta SCIM 2.0 app for full directory sync. ## Okta SAML/SSO integration Connect Okta with Tallyfy using SAML-based Single Sign-On (SSO) for automatic authentication and user provisioning. Takes about 30 minutes. :::note[You set this up yourself] SSO is self-serve. You configure both sides: build the SAML app in Okta, then paste the Okta metadata into Tallyfy under **Settings > Organization > Security > SSO**. No support ticket needed. ::: ### Requirements - Okta administrator account - A Tallyfy administrator account on any paid plan - The Tallyfy SP values from the SSO wizard (shown when you pick Okta) ### Setup overview 1. Create an Okta SAML application 2. Configure settings in both systems 3. Test the connection in the Tallyfy wizard, then turn SSO on ### Phase 1: Create Okta SAML application #### Step 1: Create a new app #### Step 2: Configure general settings ### Phase 2: Configure SAML settings #### Step 1: Obtain Tallyfy SAML values Grab Tallyfy's SAML values first - these tell Okta where to send login data: #### Step 2: Enter SAML settings in Okta Now configure Okta with those values: #### Step 3: Configure attribute statements Tell Okta which user info to send to Tallyfy: | Name | Name Format | Value | |------|-------------|-------| | email | Unspecified | user.email | | FirstName | Unspecified | user.firstName | | LastName | Unspecified | user.lastName | ![Okta attribute statements configuration](https://screenshots.tallyfy.com/oktasso-10.png) #### Step 4: Complete Okta configuration ### Phase 3: Configure Tallyfy with Okta info #### Step 1: Get Okta SAML details Okta also gives you an **Identity Provider metadata** link on this page. Copy it if you'd rather use the metadata URL method. #### Step 2: Paste Okta details into the Tallyfy wizard Back in the Tallyfy SSO wizard (**Settings > Organization > Security > SSO**), move to the **Enter IdP details** step and pick a method: #### Step 3: Test and enable ### User provisioning and access Once SSO is active: Here's how it works for your users: - Already have a Tallyfy account? They'll log in automatically - No account yet? If auto-join is on and their email is on a verified domain, Tallyfy creates an account on first login. Verify your domain under the **Domains** tab first. See [Domain verification](/products/pro/integrations/authentication/domain-verification/). ### SSO authentication flow The full authentication process from setup to user access: [Diagram removed for brevity] **Key points:** - Steps 1-6 are the one-time self-serve setup you run yourself across Tallyfy and Okta - Steps 7-14 happen every time a user logs in - Tallyfy auto-creates accounts for new users from a verified domain (step 13) using the email and name attributes from Okta ### Set up SCIM provisioning (optional) SAML handles login. SCIM handles your user roster. With Okta's SCIM 2.0 provisioning on, Okta pushes assignments and deactivations to Tallyfy automatically, so accounts appear and disappear in step with Okta and you stop paying for people who've left. To map Okta groups to Tallyfy roles, push groups whose names match Tallyfy's reserved group names (for example `tallyfy-admins`). Full details are in [SCIM provisioning](/products/pro/integrations/authentication/scim-provisioning/). ### Troubleshooting Can't log in? Check these first: - Is the user assigned to the Okta application? - Are attribute mappings exactly right? Names and formats matter. - Are users hitting 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 work well 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/)**: Set up SAML-based Single Sign-On between OneLogin and Tallyfy yourself. Create a custom SAML connector in OneLogin, then paste its metadata into the self-serve SSO wizard under Settings so your team authenticates through a special SSO URL. Add OneLogin SCIM for directory sync. ## OneLogin SAML/SSO integration Let your team sign into Tallyfy with their OneLogin credentials using SAML-based Single Sign-On (SSO). The setup takes about 30 minutes. :::note[You set this up yourself] SSO is self-serve. You configure both sides: build the SAML connector in OneLogin, then paste its metadata into Tallyfy under **Settings > Organization > Security > SSO**. No support ticket needed. ::: ### Requirements - OneLogin administrator account - A Tallyfy administrator account on any paid plan - The Tallyfy SP values from the SSO wizard (shown when you pick OneLogin) ### What you'll do 1. Create a OneLogin SAML application connector 2. Configure SAML settings in both systems 3. Paste the OneLogin metadata into the Tallyfy wizard, test, and enable ## SAML integration flow This diagram shows the OneLogin-Tallyfy SAML setup and authentication flow. [Diagram removed for brevity] ### Key points - You configure both OneLogin and Tallyfy yourself, no support hand-off - After setup, users access Tallyfy through a special SSO URL - New users from a verified domain are provisioned on first login when auto-join is on ### 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: Get Tallyfy SAML values You'll need Tallyfy's SAML values to configure OneLogin: #### Step 2: Configure the OneLogin connector #### Step 3: Configure user attributes Add these three parameters and check **Include in SAML assertion** for each: | Parameter Name | Value | |---------------|-------| | Email | Email | | FirstName | First Name | | LastName | Last Name | ![OneLogin application parameters tab with attribute mappings](https://screenshots.tallyfy.com/onelogin-6.png) 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 matching user attribute 3. Check **Include in SAML assertion** 4. Click **Save** ![Adding a new parameter in OneLogin](https://screenshots.tallyfy.com/onelogin-7.png) ![OneLogin parameter with Include in SAML assertion checked](https://screenshots.tallyfy.com/onelogin-8.png) #### Step 4: Assign users ### Phase 3: Configure Tallyfy with OneLogin info #### Step 1: Get OneLogin SAML information OneLogin can hand you a metadata link, which is the easiest thing to paste into Tallyfy. #### Step 2: Paste the metadata into Tallyfy and test Back in the Tallyfy SSO wizard (**Settings > Organization > Security > SSO**), move to the **Enter IdP details** step: ### User provisioning and access After completing the setup: When users access Tallyfy through this URL: - Existing Tallyfy users sign in automatically - New users from a verified domain get provisioned on first login when auto-join is on. Verify your domain under the **Domains** tab first. See [Domain verification](/products/pro/integrations/authentication/domain-verification/). ### Troubleshooting Running into auth issues? Check these common culprits: - The user hasn't been assigned to the OneLogin application - Parameter mappings don't match exact names - even a tiny typo breaks things - The **Include in SAML assertion** flag isn't checked - Users are going to the regular Tallyfy login page instead of the SSO URL - Still stuck? Contact Tallyfy Support ### Set up SCIM provisioning (optional) SAML signs people in. SCIM keeps your roster in sync. With OneLogin provisioning on, OneLogin pushes user adds and removals to Tallyfy automatically, so accounts track your directory and you stop paying for people who've left. To map OneLogin roles to Tallyfy roles, provision groups whose names match Tallyfy's reserved group names (for example `tallyfy-admins`). Full details are in [SCIM provisioning](/products/pro/integrations/authentication/scim-provisioning/). - **[SCIM provisioning](https://tallyfy.com/products/pro/integrations/authentication/scim-provisioning/)**: Turn on SCIM 2.0 directory sync in Tallyfy so your identity provider adds, updates, and deactivates members automatically. Generate and rotate the bearer token, map IdP groups to Tallyfy roles with reserved group names, and free up seats when people leave. Available on any paid plan. ## Keep your user list in sync automatically SCIM connects Tallyfy to your identity provider's directory so member accounts stay in sync without anyone clicking around. When someone is added to the right group in Okta, Microsoft Entra ID, or OneLogin, they get a Tallyfy account. When they leave, their access is removed and the seat frees up. You turn it on under **Settings > Organization > Security > SCIM**, on any paid plan. SCIM (System for Cross-domain Identity Management)[^1] is the standard most identity providers use to push directory changes to apps. SAML signs people in. SCIM manages who exists. They do different jobs, and for larger teams you'll usually want both. ### What you get - **Hands-off onboarding** - new hires land in Tallyfy as soon as your IdP assigns them, before they ever log in. - **Automatic deprovisioning** - when HR offboards someone in your directory, their Tallyfy access is cut and the seat is returned. This is the big one for cost control: you stop paying for ex-employees. One enterprise customer flagged exactly this problem, paying for seats of people who'd already left because removal was manual. - **Role mapping** - IdP group membership can decide each person's Tallyfy role, so admins stay admins and the rest stay standard or light. ### Turn on SCIM and get your credentials Each organization gets its own SCIM Base URL and a bearer token. The token authenticates your IdP to Tallyfy, so treat it like a password. ### Rotate or revoke the token If a token is exposed, or an admin who set it up leaves, regenerate it. Regenerating immediately revokes the old token, so any IdP still using the old one stops syncing until you paste the new one in. ### Map IdP groups to Tallyfy roles You can drive each member's Tallyfy role from their group in your identity provider. Tallyfy reads reserved group names: provision a group whose name matches the reserved name for a role, and members of that group get that role. | Reserved group name | Tallyfy role | |---------------------|--------------| | `tallyfy-admins` | Administrator | | `tallyfy-standard` | Standard | | `tallyfy-light` | Light | Name the groups in your IdP to match, then provision them through SCIM. People who aren't in any mapped group get your connection's default role. If you change someone's group in your IdP, their Tallyfy role updates on the next sync. :::caution[Don't combine SCIM with JIT auto-create] When SCIM is on, it's the source of truth for who's in your org. Leave just-in-time auto-join (the verified-domain "create account on first login" behavior) off while SCIM runs. Running both at once can double-provision people and double-count seats, because two systems try to create the same member. Pick SCIM for full directory control, or JIT auto-join for lightweight self-service, not both. ::: ### How deactivation works When your IdP sends a deactivation (the user is set inactive or unassigned), Tallyfy disables that member and releases their seat back into your pool. The account isn't deleted, so their task history stays intact for the record. If the same person is reactivated in your directory later, the next sync re-enables them. ### Troubleshooting Sync not working as expected? Check these: - The **bearer token** in your IdP matches the current Tallyfy token. If you regenerated it, the old one no longer works. - The **Base URL** is the exact one from your org's SCIM panel. - The user or group is actually assigned to the Tallyfy app in your IdP. - For role mapping, the IdP group name matches a reserved name exactly, including the `tallyfy-` prefix. - Your IdP's provisioning logs show what it sent. Most providers expose a per-user provisioning status that names the failing attribute. [^1]: SCIM is an open standard (RFC 7644) for automating user provisioning and deprovisioning between identity providers and apps. - **[SSO enforcement and break-glass](https://tallyfy.com/products/pro/integrations/authentication/sso-enforcement-and-break-glass/)**: Require SSO for your whole organization so members can only sign in through your identity provider. Enforcement needs a verified domain first, asks for step-up re-auth, and emails all admins. Org owners and admins keep a password fallback as a break-glass so a broken IdP can't lock you out. ## Make SSO the only way in Enforcement locks your organization down so members sign in only through your identity provider. Email and password logins are turned off for regular members, and manual invites are blocked, so everyone comes through SSO. You turn it on with the **Require SSO** switch under **Settings > Organization > Security > SSO**, on any paid plan. Here's the part that keeps this safe: org owners and admins always keep their password login, even under enforcement. That's the break-glass. If your identity provider goes down or a config change breaks SSO, an admin can still sign in with a password and fix it. You can't accidentally lock your whole org out. ### What enforcement changes When **Require SSO** is on: - Email and password logins are turned off for regular members - Manual member invites are blocked, so all new members arrive through your IdP - Anyone who hits the regular login page is redirected to your SAML sign-in - Owners and admins keep password login as the break-glass fallback ### You need a verified domain first The **Require SSO** switch stays disabled until you have a verified domain. That's deliberate. Enforcing SSO without proof that you own your email domain is risky, so Tallyfy gates it behind verification. If the switch is greyed out, go verify a domain first. See [Domain verification](/products/pro/integrations/authentication/domain-verification/). ### Turn on enforcement Before you flip the switch, confirm SSO actually works: run the connection test in the wizard and do a real test login. Enforcement is a safety-sensitive change, so Tallyfy adds a couple of guardrails when you turn it on. Turning enforcement on doesn't kill people's active sessions mid-work. New sign-ins go through SSO from that point on. ### The break-glass guarantee Enforcement is meant to tighten security, not to be a trap. The break-glass rule is simple: - **Regular members** can only sign in through SSO once enforcement is on. - **Owners and admins** can always fall back to password login. So if your IdP has an outage, a certificate expires, or a misconfiguration breaks the SAML flow, an admin signs in with a password, fixes the connection or turns enforcement off, and the rest of the team is back in. This is the same pattern teams expect from tools like Notion and Linear. :::note[Keep at least one admin password reachable] Make sure at least one owner or admin knows their Tallyfy password (or can reset it through their email) and isn't dependent on SSO themselves. That account is your recovery path if SSO ever breaks. ::: ### Recover from a broken IdP If SSO stops working while enforcement is on: ### Turn enforcement off You can lift enforcement at any time from the same switch. It also asks for step-up re-auth and emails the admins. With enforcement off, members can use password login again, and the change is logged in the security activity feed like every other SSO change. ### Troubleshooting - **The Require SSO switch is disabled** - you don't have a verified domain yet. Verify one under the **Domains** tab. - **A member is stuck at login** - confirm they're assigned to the app in your IdP and they're using the SSO URL. Regular members can't use password login under enforcement. - **You think you're locked out** - you're not, if you're an owner or admin. Use the normal login page with your password. If you've forgotten it, reset it through your email. - **Changes you didn't expect** - the security **Activity** tab shows who changed enforcement and when, so you can see exactly what happened. ### Analytics - **[How Tallyfy Analytics works](https://tallyfy.com/products/pro/integrations/analytics/how-does-tallyfy-analytics-process-my-data/)**: Tallyfy Analytics processes your workflow data through a five-step pipeline, converting events into Apache Parquet files stored in Amazon S3. Connect BI tools like Power BI or Tableau using SQL queries through Amazon Athena. ## How Tallyfy Analytics prepares your data Tallyfy Analytics transforms your workflow data into a format that BI tools like Power BI and Tableau can query directly. Here's how your data travels from Tallyfy to those tools. ### Overview of the data pipeline Your data goes through five steps to become analytics-ready: 1. **Detecting an event** - Tallyfy watches for changes like task completions, process status updates, and user changes. 2. **Extracting the data** - Tallyfy captures a complete snapshot of the process where the event occurred. 3. **Converting the format** - Tallyfy converts the data to Apache Parquet[^1] for fast, compressed analysis. 4. **Storing securely** - Everything lands in your private Amazon S3 storage bucket. 5. **Providing access** - You receive AWS credentials to connect your BI tools. ### How the pipeline works in detail #### 1. Spotting an event Tasks get completed. Statuses change. Forms get submitted. Processes are created, archived, or restored. When these actions happen in Tallyfy, the system queues them for analytics processing. #### 2. Getting the data Each queued event triggers a full process snapshot. The export captures: - Process metadata (owner, status, template name/version, tags, completion timestamps) - Every task's status, assignees, and due dates - Form field questions and answers - User and guest assignments (including group-based assignments) - Comments and reported issues Tallyfy initially saves this data as a CSV file. :::note[Timestamp storage format] Timestamps in the exported data use `Y-m-d H:i:s` format without timezone information - for example, `2024-03-15 14:30:00`. This keeps data storage consistent for analysis across different timezones. In Tallyfy's interface, timestamps convert to each user's 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 CSV alone won't cut it for serious analytics. Tallyfy automatically converts it to Apache Parquet format using snappy compression, which: - Queries much faster than raw CSV files - Takes up significantly less storage space - Works natively with Power BI, Tableau, and other BI tools #### 4. Storing safely Your Parquet files land in a dedicated S3 bucket: - Each organization gets a **private folder** - no other accounts can access it - **AWS encryption at rest** protects stored data - Tallyfy stores both the Parquet files and original CSVs for redundancy - Files stay available throughout your Tallyfy Analytics subscription #### 5. Allowing access for analysis Tallyfy provides you with AWS IAM credentials that let your BI tools connect. With these credentials, you can: - Query your data through **Amazon Athena[^2]** without managing any database infrastructure - Run SQL queries against your process data - Use standard JDBC/ODBC connections (supported by virtually every BI tool) - Build dashboards and reports on top of the queried data ### Technical diagram This diagram shows the complete data flow: ![Tallyfy Analytics data pipeline from API to BI tools](https://screenshots.tallyfy.com/tallyfy/pro/analytics-data-pipeline-diagram.png) ### Activating analytics A few things to know before you start: - Data processing doesn't begin until you activate Tallyfy Analytics on your account - You'll receive your AWS IAM credentials right after activation - You can connect most BI tools in about 15 minutes using standard JDBC/ODBC 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's CSV export flattens a running process into a 49-column spreadsheet. Each row represents a task, form field, or comment, making it easy to analyze workflow data in any spreadsheet or BI tool. ## Tallyfy CSV export structure Exporting a running process gives you a CSV file with 49 columns[^1] covering tasks, form answers, and comments. Each row represents a single task, form field, kick-off field, or comment - the CSV flattens your process hierarchy into a flat table you can open in any spreadsheet tool. ### How to export a process to CSV 1. Open the running process you want to export. 2. Click **Settings** (top right). 3. Scroll to the bottom of the settings panel. 4. Click **Export CSV**. ![Export CSV option in Tallyfy process settings](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-export-csv.png) ### How the data is organized Your process has layers - template details, tasks, form fields within those tasks, comments on tasks. The CSV flattens all of this into rows. The `type` column tells you what each row represents: `process_task`, `process_task_data` (a form field), `process_task_comment`, or `kick_off_task`. *If you use Tallyfy Analytics, the data you query through reporting tools (via Amazon Athena) shares this same structure - just stored in Parquet[^2] format for faster querying.* ### Column reference The 49 columns fall into five groups: #### Process and template info (columns 1-13) :::note[Template vs. Blueprint] Column names use "Blueprint" - that's the API name for what you see as "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. * **process_tag**: Tags added to this process run. * **process_owner**: Full name of the process owner. * **process_owner_id**: ID of the process owner. * **total_tasks_in_process**: Total task count in the process (including hidden tasks). * **tasks_completed**: Number of finished tasks. * **process_status**: Current status (e.g. active, problem, or complete). * **process_last_modified**: Date/time the process was last updated. This changes on any modification (edits, archiving, tag changes) - not just completion. For completion timing, use `process_completed_at` instead. * **process_completed_at**: Date/time when the process was marked complete. Empty for active or incomplete processes. Use this for calculating process duration and completion metrics. #### Task info (columns 14-28) * **type**: What this row represents - `process_task`, `process_task_data` (form field), `process_task_comment`, or `kick_off_task` (kick-off form field). * **has_form_fields**: Always `Yes` in the current export format. * **kick_off_task_id**: ID of the kick-off form field (populated only for `kick_off_task` rows). * **kick_off_task_name**: Label of the kick-off form field. * **process_task_id**: Unique ID for this task instance. * **process_task_status**: Either `shown` or `hidden`. Hidden tasks were auto-skipped by automation rules. Task completion is tracked via `completed_on` instead. * **process_task_name**: Name of the task. * **process_task_alias**: Stable step ID from the template - useful for comparing the same step across different process runs. * **process_task_data_id**: ID of the form field (populated only for `process_task_data` rows). * **process_task_data_name**: Name of the parent task this form field belongs to. * **process_task_comment_id**: ID of the comment (populated only for `process_task_comment` rows). * **process_task_comment_name**: Name of the task this comment belongs to. * **milestone_id**: ID of the milestone attached to this task (if any). * **milestone_name**: Name of the milestone (if any). * **milestone_position**: Position of the milestone in the process sequence. #### Assignment and timing info (columns 29-37) * **user_assigned**: Comma-separated names of assigned members. Group assignments appear as `GROUP_{id}_{name}`. * **assigned_user_id**: Comma-separated IDs of assigned members. * **guest_assigned**: Comma-separated emails of assigned guests. * **total_users_assigned**: Number of members assigned. * **total_guests_assigned**: Number of guests assigned. * **total_assignees**: Total people assigned (members + guests). * **completed_by**: ID of the person who completed the task. Shows `0` if not yet completed. * **assigned_or_shown_on**: Date/time the task appeared or was assigned. Empty for hidden (auto-skipped) tasks. * **due_by**: Task deadline date/time. * **completed_on**: Date/time the task was completed. :::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 to NaN (Not a Number) 3. During Parquet conversion, NaN values become the literal string "NaN" 4. Your analytics tool reads "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" for accurate date calculations. ::: #### Form field info (columns 38-41) *(These columns only have data when the row `type` is `process_task_data` or `kick_off_task`)* * **no_of_form_fields**: Number of form fields in the parent task (or kick-off form). * **form_field_type**: Field type (text, date, dropdown, radio, file, etc.). * **question_in_form_field**: The label/question for this field. * **answer_in_form_field**: The answer entered into this field. Only populated if the task has been completed. #### Comments and issues info (columns 42-49) *(These columns are populated on `process_task_comment` rows)* * **issue_reported**: Was this comment reporting an issue? (Yes/No). * **no_of_issue_reported**: Total issues reported on the parent task. * **issue_resolved**: Was the reported issue resolved? (Yes/No). * **no_of_issue_resolved**: Total resolved issues on the parent task. * **total_comments**: Number of comments on the parent task. * **comment**: The text content of the comment. * **last_modified**: When this row's data was last updated. ### Dates and reporting tools If you're querying Tallyfy Analytics with Power BI or Tableau, you'll format date columns using Amazon Athena / Presto SQL functions. :::note[Timestamp handling] All timestamps in CSV exports are stored in ISO 8601 format[^3] without timezone information. In Tallyfy's UI, these timestamps are automatically converted to your personal timezone setting. ::: :::tip[Tracking actual work time] Want to measure how long tasks actually take to complete? Check out [how to track time spent on tasks](/products/pro/tutorials/how-to/track-time-in-tasks/). Time-tracking form fields appear in your CSV exports, giving you data about actual effort versus elapsed calendar time. ::: ### Example CSV view Here's what the exported data looks like 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 - **[Google Analytics and Mixpanel integration](https://tallyfy.com/products/pro/integrations/analytics/how-to-set-up-google-analytics-integration-on-tallyfy/)**: Tallyfy sends usage data to your Google Analytics (GA4) or Mixpanel account when you paste a Measurement ID or project token. Track which templates and processes your team and guests use, and build custom reports on workflow adoption and task completions. ## Connect Google Analytics or Mixpanel to Tallyfy Tallyfy can send usage data directly to your own Google Analytics (GA4) or Mixpanel account. Paste your Measurement ID or project token, and you'll see how your team interacts with templates, processes, and tasks, right inside your analytics dashboards. This works for both internal members and guests[^1]. ### Why bother tracking? - **See what gets used**: Which templates or documents get the most views? - **Spot trends**: Identify your busiest workflows and when people access them - **Measure engagement**: Track page views, task completions, and process launches over time ## Setting up Google Analytics (GA4) ### What you need - A Google Analytics 4 account with admin rights - A Tallyfy Pro or Enterprise plan - Administrator permission in Tallyfy ### Step 1: Get your GA4 Measurement ID 1. In Google Analytics, go to **Admin** > **Data Streams** 2. Select your web data stream and copy the **Measurement ID** (format: `G-XXXXXXXXXX`) ### Step 2: Connect Tallyfy to Google Analytics That's it. Tallyfy starts sending page views and events to your GA4 property. ### What Tallyfy sends to GA4 Tallyfy automatically sends events enriched with custom dimensions[^2] including: | Dimension | Event Parameter | Description | |-----------|----------------|-------------| | Organization ID | `orgId` | Your Tallyfy organization | | Task ID | `taskId` | Specific task being viewed | | Process ID | `processId` | Active process instance | | Template ID | `blueprintId` | Template being accessed | | Template Step ID | `blueprintStepId` | Specific step in a template | Each event also includes user context (user ID, email, role) and session details automatically. You can create custom dimensions in GA4 under **Admin** > **Data display** > **Custom definitions** to surface these parameters in your reports. ### Cross-device user tracking (optional) Tallyfy sends a `user_id` with every event, which means GA4 can track the same person across their laptop, phone, and tablet. Go to **Admin** > **Reporting identity** in GA4 to configure how it identifies users: blended, observed, or device-based. :::note[Data takes time] GA4 typically takes 24-48 hours to process new data. Don't worry if nothing shows up right away. ::: ## Setting up Mixpanel ### How to connect Mixpanel ### What Mixpanel tracks Mixpanel captures the same events Tallyfy sends to GA4, including: - Page views across templates and processes - Task completions - Process launches - Template views ![Mixpanel analytics showing blueprint viewed events](https://screenshots.tallyfy.com/tallyfy/pro/analytics-blueprint-viewed-events.png) Mixpanel also receives user profile data (name, email, role) and organization context, so you can build user-level funnels and cohort analysis. :::caution[Privacy notice] Mixpanel collects detailed event data including user information. Make sure your company's privacy policy covers this. ::: ### What you can do with the data Once connected, both Google Analytics and Mixpanel let you: - Build custom reports on Tallyfy usage patterns - Create dashboards tracking process adoption - Set up alerts when usage changes - Export data for deeper analysis [^1]: Unlimited free external users who access Tallyfy via guest_code authentication [^2]: GA4 event parameters that capture Tallyfy-specific context beyond standard page view metrics - **[One-time questions vs recurring dashboards](https://tallyfy.com/products/pro/integrations/analytics/one-time-questions-vs-recurring-dashboards/)**: Tallyfy gives you analytics two ways - ask Claude a one-time question through the Tallyfy MCP server, or build a recurring dashboard on Tallyfy Analytics with a BI tool. This guide helps you pick the right one for each question, and when to graduate from one to the other. ## Choosing between a one-time answer and a standing dashboard Most workflow questions are one-time. "Which approvals are stuck right now?" or "How long did onboarding take last quarter?" You ask, you act, you move on. For those, just ask Claude through the [Tallyfy MCP server](/products/pro/integrations/mcp-server/). No setup, no dashboard to maintain. A dashboard is a different animal. A dashboard is a question you've decided to ask forever. It earns its keep only when the same numbers get checked again and again by a team that needs to stay aligned. For that, Tallyfy Analytics (your data in Amazon Athena[^1]) plus a BI tool like Power BI or Tableau is the better fit. Here's the rule that saves you the most pain: ask first, build later. ### When to just ask Claude Reach for Claude and the Tallyfy MCP server when: - You want an answer now, not next week. - The question is exploratory and you're still figuring out what matters. - It changes every time (different team, date range, or template). - Only you or a couple of people need it. Examples: "graph my templates by number of steps", "which processes stalled this month", "compare cycle time before and after we changed the quotation flow". How it works: connect the [Tallyfy MCP server to Claude](/products/pro/integrations/mcp-server/claude-anthropic/), then ask in plain English. Claude reads your live Tallyfy data and answers, often with a chart you can drop straight into a document. The [worked example](/products/pro/integrations/mcp-server/claude-anthropic/analytics-with-claude/) walks through a first query end to end. ### When to build a recurring dashboard Build a standing dashboard on Tallyfy Analytics when: - The same people check the same numbers on a schedule. - The team needs one agreed source of truth. - Targets or decisions ride on it (SLAs, monthly reviews, board reports). - You need to see history over many months. Examples: a weekly operations scorecard, an SLA board everyone watches, an executive monthly review. How it works: activate [Tallyfy Analytics](/products/pro/integrations/analytics/), which copies your workflow data into a private Amazon Athena environment, then connect [Power BI](/products/pro/integrations/analytics/powerbi/), [Tableau](/products/pro/integrations/analytics/tableau/), or [Looker](/products/pro/integrations/analytics/looker/). ### A middle path: refresh a Claude report on a schedule You don't always have to choose. A common pattern is to have Claude build a report or chart once, then re-run the same prompt on a schedule with fresh data. Weekly. Monthly. Whatever suits. It's a "good enough" recurring report without standing up a full BI dashboard. When that report becomes something the team relies on, that's your signal to graduate it to Tallyfy Analytics. ### One caution: numbers people depend on need governance Asking Claude is fast and flexible, and that's exactly why it shines for exploring. But a one-time answer is only as good as the question behind it. When a number drives money, a target, or a promise to a customer, you want it defined once and computed the same way every time. A governed dataset (Tallyfy Analytics) gives you that. Anthropic's own data team makes the point well: for analytics, the same question has to return the same answer, so structure and clear definitions matter more than raw flexibility[^2]. ### Quick decision table | If the question is... | Use this | | --- | --- | | Asked once, exploratory, personal | Claude + Tallyfy MCP server | | Repeated on a schedule, mostly for you | A Claude report you refresh on a schedule | | Shared, decision-grade, needs history | Tallyfy Analytics + a BI tool | [^1]: Amazon's serverless query service. It runs standard SQL over your data without you managing any servers. [^2]: Anthropic, "How Anthropic enables self-service data analytics with Claude" [1]. - **[Why use BI platforms vs. native analytics?](https://tallyfy.com/products/pro/integrations/analytics/why-use-a-dedicated-bi-platform-with-tallyfy/)**: Tallyfy connects your process data to BI platforms like Power BI and Tableau instead of building native reports. Specialized analytics tools offer stronger visualizations, deeper analysis, and let you combine workflow data with other systems while keeping it fully portable. ## Why Tallyfy connects to BI tools instead of building native reports Instead of building basic reporting inside Tallyfy, we make it easy to connect your process data to BI tools you already use - like Power BI, Tableau, or Looker. Dedicated BI platforms do data analysis better than any workflow tool could. That's by design. ### Specialized tools do it better BI platforms exist for one reason - data analysis. They offer far more than we'd ever build internally: - **Stronger visualizations** - Purpose-built charting, dashboards, and interactive reports - **Deeper analysis** - Statistical analysis, predictions, and AI-powered insights - **Constant updates** - BI companies ship new features continuously - **Familiar interfaces** - Your team already knows these tools ### Combine Tallyfy data with everything else External BI tools let you mix Tallyfy data with information from other systems. The result? A complete picture: - Track how process efficiency affects financial results - Link workflow times to customer satisfaction scores (note: 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 in one dashboard ### No lock-in, full flexibility You're not stuck with one analytics solution. Tallyfy's approach keeps your options open: - **Pick your BI tool** - Choose whichever platform fits your organization best - **Switch freely** - Change BI tools later without losing access to your Tallyfy data - **Custom dashboards** - Build the exact reports different teams and roles need - **Scale independently** - Grow your analytics without changing your workflow platform ### Your data stays portable Your workflow data isn't trapped. It's ready for whatever you need next: - **Data science access** - Give your data team direct access to raw process data - **ML-ready** - Train predictive models on your workflow patterns and outcomes - **Standard formats** - SQL and CSV interfaces ensure compatibility with future tools - **Full ownership** - You keep complete control of your company's process data ### Use what you already have You've already invested in analytics tools and talent. Use them: - Keep using existing Power BI, Tableau, or Looker licenses - Your data analysts already know these platforms - no retraining - Skip paying for separate reporting systems - Spend time on insights, not learning new tools Tallyfy handles workflow management. Top BI tools handle your analytics. Simple. ### When Claude is enough, and when you need a BI platform Not every question needs a dashboard. If you just want an answer right now ("which processes stalled this week?"), the fastest path is to ask Claude through the [Tallyfy MCP server](/products/pro/integrations/mcp-server/claude-anthropic/). No setup, no standing report to maintain. The [run analytics with Claude](/products/pro/integrations/mcp-server/claude-anthropic/analytics-with-claude/) guide walks through it. Reach for a dedicated BI platform when the same numbers get checked again and again, by a team that needs one source of truth, with history stretching over many months. That's what Tallyfy Analytics plus Power BI or Tableau is built for. For a side-by-side on which to use when, see [one-time questions vs recurring dashboards](/products/pro/integrations/analytics/one-time-questions-vs-recurring-dashboards/). - **[Looker](https://tallyfy.com/products/pro/integrations/analytics/looker/)**: Looker and Looker Studio both connect to Tallyfy Analytics through Amazon Athena so teams can build interactive dashboards and drill into workflow performance data without writing SQL using either the enterprise platform or the free visualization tool. ## Connecting Looker to Tallyfy Analytics Looker connects to Tallyfy Analytics through Amazon Athena, letting you build interactive dashboards from your workflow data. Your whole team can click, filter, and drill into process performance - no SQL required. :::note[Looker vs Looker Studio] This covers both **Looker** (Google Cloud's enterprise BI platform) and **Looker Studio** (free visualization tool, formerly Google Data Studio). Both connect to Tallyfy Analytics through Amazon Athena using different methods. Pick whichever fits your needs and budget. ::: ### What you can build - **Interactive exploration** - Filter and drill down through workflow data without writing queries - **Embedded dashboards** - Share live analytics with people who don't need full BI access - **Real-time monitoring** - Watch processes unfold with dashboards that update as work happens - **Executive overviews** - Give leadership a high-level view with drill-down into details - **Bottleneck detection** - Spot slowdowns in your processes before they become problems - **Compliance reporting** - Prove SLA compliance with timestamp evidence ### How the connection works | Layer | Role | |-------|------| | Tallyfy Analytics | Your process data stored in Amazon S3 | | Amazon Athena[^1] | Query engine that runs SQL on your data lake | | Simba JDBC driver | Connects Looker to Athena | | Looker | Build models, create visualizations, embed dashboards | ### Authentication When Tallyfy provisions your Analytics account, you'll get two credential sets: - **AWS IAM Login** (username/password) - For AWS web console access only - **Access Key and Secret Access Key** - What Looker actually needs for the connection :::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 "security token invalid" errors. ::: ### Performance tips - **Result streaming** - Enable streaming for large result sets 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 - **Aggregate awareness** - Pre-calculate common metrics so dashboards load faster :::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 **Looker (enterprise)** - takes about 15-20 minutes: 1. Confirm you have 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 connection guide below **Looker Studio (free)** - takes about 10-15 minutes: 1. Confirm 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 [^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 can't connect directly to AWS Athena, the engine behind Tallyfy Analytics. You can bridge the gap through Redshift Spectrum or a supported warehouse like Snowflake, or switch to Athena-compatible BI tools like Power BI, Tableau, or AWS QuickSight. ## Sigma Computing and Tallyfy Analytics Sigma Computing can't connect directly to AWS Athena - which is the query engine behind Tallyfy Analytics. If you're set on using Sigma, you'll need a workaround. Sigma is a cloud-native BI platform that gives business users a spreadsheet-like interface on top of cloud data warehouses. No SQL required. If you're comfortable with Excel, you'll pick it up fast. ### What Sigma connects to Sigma requires persistent, always-on connections to data warehouses. It supports these platforms natively: | Platform | 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 | AWS Athena isn't on this list because it's serverless - it doesn't maintain persistent connections. Athena runs queries on demand against S3 storage, which is a fundamentally different pattern than what Sigma expects. ### Workarounds for Tallyfy Analytics Three paths forward: **Bridge through Redshift Spectrum** - If you already have Amazon Redshift, use Redshift Spectrum to query the S3 data where Tallyfy Analytics stores everything. Then connect Sigma to Redshift normally. **Migrate to a supported warehouse** - Copy your analytics data into Snowflake, BigQuery, or Redshift. Any of these work natively with Sigma. **Switch BI tools instead** - If you'd rather keep Athena, use a tool that supports it directly: - Power BI (with the appropriate ODBC drivers) - Tableau (via JDBC connection) - AWS QuickSight (built specifically for Athena) ### Practical recommendation If you're already using Tallyfy Analytics, Power BI or Tableau are the straightforward choices - they connect to Athena without extra infrastructure. Sigma is a strong platform, but the Athena gap means added complexity you probably don't need. Keep an eye on Sigma's roadmap. They may add Athena support in the future, and submitting a feature request to Sigma directly helps signal demand. - **[Power BI](https://tallyfy.com/products/pro/integrations/analytics/powerbi/)**: Tallyfy's Power BI integration connects your workflow data through Amazon Athena so you can build interactive dashboards for process optimization, team performance analysis and executive reporting. ## Connecting Power BI to Tallyfy data Power BI connects to your Tallyfy workflow data through Amazon Athena[^1], letting you build dashboards and reports around process performance. You can visualize completion times, task metrics, form field data and team activity - all from live data. ### What you can do - **Interactive dashboards** - Build visualizations that respond to filters and member or guest interactions - **Process analysis** - Measure workflow efficiency with duration and completion metrics - **Custom reports** - Design reports for different teams - **Live data access** - Query your process data directly through Amazon Athena - **Cross-system analysis** - Combine Tallyfy data with other business systems in Power BI ### How it works Tallyfy Analytics stores your process data in Amazon Athena - a serverless query engine for your workflow data. Power BI connects through ODBC drivers[^2], giving you access to: 1. Process completion times and volumes 2. Task assignments and performance metrics 3. Form field data collected during processes 4. Member and guest participation statistics ### Common use cases | Business need | Power BI solution | |---------------|-------------------| | Process optimization | Duration analysis dashboards highlighting bottlenecks | | Team performance | Member or guest activity reports with completion metrics | | Data collection | Visualization of form field data across processes | | Executive reporting | KPI dashboards with drill-down capabilities | | Compliance tracking | Audit trails and process compliance documentation | :::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 You get two sets of credentials when Tallyfy Analytics is provisioned: - **AWS IAM Login** (username/password) - Only for the AWS web console - **Access Key and Secret Access Key** - Used for Power BI connections :::note[Important] Power BI needs the Access Key and Secret Access Key - not the IAM login credentials. Token-based authentication works better with analytics tools. ::: ### Getting started 1. Confirm you have an active [Tallyfy Analytics](/products/pro/integrations/analytics/) subscription 2. Download and install Power BI Desktop (it's free) 3. Get your Access Key and Secret Access Key from Tallyfy 4. Follow the connection guide below to set everything up Setup takes about 15 minutes. [^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 - **[Tableau](https://tallyfy.com/products/pro/integrations/analytics/tableau/)**: Tableau connects to Tallyfy Analytics through Amazon Athena, letting teams build interactive dashboards. Spot workflow bottlenecks, track SLA compliance, and analyze form data without writing code. ## Connecting Tableau to Tallyfy Analytics Tableau connects directly to Tallyfy Analytics, turning raw process data into interactive dashboards you can actually explore. Filter, drill down, spot bottlenecks - all without writing code or wrestling with spreadsheets. ### What you can do - **Visual process analysis** - Reveal workflow patterns you'd never spot in raw data - **Interactive dashboards** - Click to filter, drill down, and explore on the fly - **Bottleneck detection** - See where tasks get stuck and why - **Flexible chart types** - Charts, heatmaps, scatter plots - pick what fits your data - **Self-service reporting** - 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 | Build visualizations without coding | | Calculation engine | Apply formulas and transformations to workflow data | | Publishing | Share dashboards with team members and leaders | | Scheduled refreshes | Automate data updates on a set schedule | ### Common use cases 1. **Process efficiency** - Track completion times and spot improvement opportunities 2. **Team performance** - See who's ahead of schedule and who needs support 3. **Form data analysis** - Turn form responses into trends and insights 4. **SLA compliance** - Monitor whether you're hitting response-time targets 5. **Executive dashboards** - Give leadership a high-level view of operations ### How the integration works The data flows through a straightforward chain: - **Tallyfy Analytics** - Your process data stored securely in Amazon S3 - **Amazon Athena** - Query that data with standard SQL - **JDBC driver** - Connects Tableau to Athena - **Tableau Desktop** - Where you build your visualizations - **Tableau Server/Online** (optional) - Share dashboards across your organization ### Getting started 1. Activate Tallyfy Analytics (takes about 10 minutes) 2. Download and install Tableau Desktop 3. Connect to your data - the setup guide walks you through each step 4. Drag and drop to create your first visualization 5. Share what you find with your team The articles below cover the connection setup and sample visualizations to get you started. - **[Snowflake](https://tallyfy.com/products/pro/integrations/analytics/snowflake/)**: Snowflake can query Tallyfy Analytics data stored as Parquet files in Amazon S3. Set up an external stage with your AWS credentials and run SQL queries against process and member data with no ETL pipeline needed. ## Connecting Snowflake to Tallyfy Analytics Snowflake can read your Tallyfy Analytics data directly from S3 - no data duplication or ETL pipelines needed. If you already have Tallyfy Analytics enabled, you have everything you need to get started. Your analytics data is stored as Apache Parquet[^1] files in Amazon S3. Snowflake reads these files natively through external stages, giving you full SQL access to your process and member data. :::note[Prerequisites] Tallyfy Analytics must be enabled for your organization. If you don't have analytics credentials yet, contact your Tallyfy account manager to get set up. ::: ### What you'll need When Tallyfy provisions analytics for your organization, you receive: - **Access Key ID** - Your AWS access key (token-based authentication) - **Secret Access Key** - Your AWS secret key - **S3 Location** - The path to your organization's analytics data - **Region** - `us-west-2` (all Tallyfy Analytics data is stored here) These are the same credentials you may already use for Athena, Power BI, or Tableau connections. Snowflake uses the same Access Key and Secret Access Key. ## Setting up Snowflake ### Step 1: Create a storage integration The storage integration tells Snowflake where your data lives and how to authenticate. Run this in your Snowflake worksheet: ```sql CREATE OR REPLACE STORAGE INTEGRATION tallyfy_analytics_integration TYPE = EXTERNAL_STAGE STORAGE_PROVIDER = 'S3' ENABLED = TRUE STORAGE_AWS_ROLE_ARN = '' STORAGE_ALLOWED_LOCATIONS = ('s3://YOUR_S3_LOCATION/') STORAGE_AWS_EXTERNAL_ID = ''; ``` :::note[Using key-based authentication instead] If your Snowflake account doesn't use IAM role-based access, you can skip the storage integration and provide your AWS credentials directly in the stage definition (shown in Step 2 below). Key-based authentication is simpler and works well for most Tallyfy Analytics setups. ::: ### Step 2: Create an external stage The external stage points Snowflake to your specific analytics data folder. This is where you use the S3 location and AWS credentials provided by Tallyfy. **With key-based authentication (recommended for most setups):** ```sql CREATE OR REPLACE STAGE tallyfy_analytics_stage URL = 's3://YOUR_S3_LOCATION/' CREDENTIALS = ( AWS_KEY_ID = 'YOUR_ACCESS_KEY_ID' AWS_SECRET_KEY = 'YOUR_SECRET_ACCESS_KEY' ) FILE_FORMAT = (TYPE = PARQUET); ``` **With storage integration (if using IAM roles):** ```sql CREATE OR REPLACE STAGE tallyfy_analytics_stage STORAGE_INTEGRATION = tallyfy_analytics_integration URL = 's3://YOUR_S3_LOCATION/' FILE_FORMAT = (TYPE = PARQUET); ``` Replace `YOUR_S3_LOCATION`, `YOUR_ACCESS_KEY_ID`, and `YOUR_SECRET_ACCESS_KEY` with the values from your Tallyfy Analytics setup. ### Step 3: Verify the connection Check that Snowflake can see your files: ```sql LIST @tallyfy_analytics_stage; ``` You should see a list of Parquet files - your process analytics data and member list. ## Querying your data ### Process and task data Each Parquet file in the analytics folder contains data about a specific process run. To query across all your process data: ```sql SELECT $1:process_name::STRING AS process_name, $1:process_status::STRING AS process_status, $1:process_task_name::STRING AS task_name, $1:process_task_status::STRING AS task_status, $1:user_assigned::STRING AS assigned_to, $1:completed_on::STRING AS completed_date, $1:due_by::STRING AS due_date FROM @tallyfy_analytics_stage/analytics/ (FILE_FORMAT => 'tallyfy_parquet'); ``` ### Member data Your organization's member list is available as a separate Parquet file: ```sql SELECT $1:email::STRING AS email, $1:full_name::STRING AS full_name, $1:job_title::STRING AS job_title, $1:is_active::STRING AS is_active, $1:last_login_at::STRING AS last_login, $1:team::STRING AS team FROM @tallyfy_analytics_stage/members/ (FILE_FORMAT => 'tallyfy_parquet'); ``` ### Create a file format for cleaner queries To avoid repeating format options, create a named file format: ```sql CREATE OR REPLACE FILE FORMAT tallyfy_parquet TYPE = PARQUET SNAPPY_COMPRESSION = TRUE; ``` ## Common analytics queries ### Process completion summary ```sql SELECT $1:blueprint_name::STRING AS template_name, COUNT(DISTINCT $1:process_id::STRING) AS total_runs, COUNT(CASE WHEN $1:process_status::STRING = 'complete' THEN 1 END) AS completed, COUNT(CASE WHEN $1:process_status::STRING = 'active' THEN 1 END) AS in_progress FROM @tallyfy_analytics_stage/analytics/ (FILE_FORMAT => 'tallyfy_parquet') GROUP BY template_name ORDER BY total_runs DESC; ``` ### Overdue tasks ```sql SELECT $1:process_name::STRING AS process_name, $1:process_task_name::STRING AS task_name, $1:user_assigned::STRING AS assigned_to, $1:due_by::STRING AS due_date, $1:process_task_status::STRING AS status FROM @tallyfy_analytics_stage/analytics/ (FILE_FORMAT => 'tallyfy_parquet') WHERE $1:process_task_status::STRING != 'complete' AND $1:due_by::STRING < CURRENT_DATE()::STRING AND $1:due_by::STRING != '' AND $1:due_by::STRING != 'nan'; ``` ### Task completion by assignee ```sql SELECT $1:user_assigned::STRING AS assignee, COUNT(*) AS tasks_completed, COUNT(DISTINCT $1:process_id::STRING) AS processes_involved FROM @tallyfy_analytics_stage/analytics/ (FILE_FORMAT => 'tallyfy_parquet') WHERE $1:process_task_status::STRING = 'complete' AND $1:user_assigned::STRING != '' AND $1:user_assigned::STRING != 'nan' GROUP BY assignee ORDER BY tasks_completed DESC; ``` ### Form field responses ```sql SELECT $1:process_name::STRING AS process_name, $1:question_in_form_field::STRING AS question, $1:answer_in_form_field::STRING AS answer, $1:completed_on::STRING AS answered_on FROM @tallyfy_analytics_stage/analytics/ (FILE_FORMAT => 'tallyfy_parquet') WHERE $1:form_field_type::STRING != '' AND $1:form_field_type::STRING != 'nan'; ``` ## Data fields reference ### Process and task fields All fields are stored as STRING type in the Parquet files. Cast them as needed in your queries. | Field | Description | |-------|-------------| | `blueprint_id` | Template ID | | `blueprint_name` | Template name | | `blueprint_version` | Template version number | | `process_id` | Unique process run ID | | `process_name` | Name of the running process | | `process_tag` | Process tag or label | | `process_owner` | Process owner name | | `process_status` | Current status (active, complete, archived) | | `process_completed_at` | Timestamp when process was completed | | `process_task_id` | Task ID within the process | | `process_task_name` | Task name | | `process_task_status` | Task status (active, complete) | | `type` | Task type | | `user_assigned` | Assigned user name | | `assigned_user_id` | Assigned user ID | | `guest_assigned` | Assigned guest email | | `total_assignees` | Total number of assignees | | `assigned_or_shown_on` | Date task was assigned | | `due_by` | Task deadline | | `completed_on` | Date task was completed | | `completed_by` | Who completed the task | | `has_form_fields` | Whether task has form fields | | `form_field_type` | Type of form field | | `question_in_form_field` | Form field label/question | | `answer_in_form_field` | Form field response | | `issue_reported` | Whether an issue was reported | | `no_of_issue_reported` | Number of issues reported | | `total_comments` | Number of comments | | `comment` | Comment text | | `milestone_name` | Milestone name if applicable | ### Member fields | Field | Description | |-------|-------------| | `id` | Member ID | | `email` | Email address | | `full_name` | Full name | | `first_name` | First name | | `last_name` | Last name | | `job_title` | Job title | | `team` | Team name | | `is_active` | Active status | | `is_suspended` | Suspended status | | `created_at` | Account creation date | | `last_login_at` | Last login timestamp | | `timezone` | User timezone | | `country_id` | Country identifier | ## Important notes **Data format** - All fields in the Parquet files are cast to STRING. You'll need to cast dates and numbers in your Snowflake queries as needed. **NULL handling** - Empty values may appear as blank strings or the literal string `nan` (a side effect of the Pandas conversion). Filter both in your queries: ```sql WHERE $1:field_name::STRING != '' AND $1:field_name::STRING != 'nan' ``` **Timestamps** - Date fields use ISO 8601 format without timezone (e.g., `2025-03-15T14:30:00`). These represent UTC times. **Data freshness** - Analytics data is updated when process events occur (task completions, status changes, form submissions). There's no fixed refresh schedule - data appears as events happen. **Existing Athena access** - Snowflake and Athena can both read the same S3 data simultaneously. Adding Snowflake doesn't affect your existing Athena, Power BI, Tableau, or Looker connections. **Region requirement** - Your Snowflake account should ideally be in `us-west-2` (Oregon) for best performance, since the analytics data is stored in that region. Cross-region access works but adds latency. [^1]: Apache Parquet is a columnar storage format optimized for analytics queries, using Snappy compression for efficient storage ### 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 through a CData or OWOX connector in about 10-15 minutes. Build free shareable dashboards showing process volumes, task durations, and completion rates. ## Connect Looker Studio to Tallyfy data Looker Studio connects to Tallyfy Analytics through a third-party connector in about 10-15 minutes. You get free, shareable dashboards from your workflow data - no enterprise BI license needed. :::note[Looker Studio vs Looker] This guide covers **Looker Studio** (the free visualization tool). For **Looker** (Google Cloud's enterprise BI platform), see the [Looker connection guide](/products/pro/integrations/analytics/looker/how-to-connect-looker-to-tallyfy-data/) instead. ::: ### Requirements Before you start, you'll need: - Tallyfy Analytics subscription activated for your organization - Free Looker Studio account (sign up at [lookerstudio.google.com](https://lookerstudio.google.com)) - AWS Access Key credentials from Tallyfy Support - A third-party connector subscription (CData or OWOX) :::caution[No native Athena support] Looker Studio lacks built-in Amazon Athena connectivity, unlike enterprise Looker. A third-party connector bridges the gap. Setup is still quick. ::: ## Authentication overview Tallyfy Analytics data lives in Amazon Athena, which supports two authentication methods: | Method | Description | Use for | |--------|-------------|---------| | IAM Username/Password | Web console access credentials | AWS Console only | | Access Key/Secret | Token-based authentication | Connector authentication (recommended) | :::caution[Two separate credential sets] Tallyfy provisions two distinct credential sets: - **AWS IAM login** - for the AWS web console only - **Access Key + Secret Access Key** - for connecting Looker Studio connectors ::: ## Connector options Two connectors work well for Athena-to-Looker Studio integration: ### Option 1: CData Connect Cloud - **Pricing**: Subscription-based (check [CData pricing](https://www.cdata.com/pricing/)) - **Setup time**: 10-15 minutes - **Highlights**: Cloud-to-cloud connectivity, automatic query optimization, no data replication ### Option 2: OWOX BI connector - **Pricing**: Free (check [OWOX connector page](https://www.owox.com/products/athena-to-looker-studio-connector)) - **Setup time**: 10-15 minutes - **Highlights**: Direct AWS integration, no intermediate processing :::tip[Choosing a connector] Both work well with Tallyfy Analytics. Pick CData if you need broader data connectivity beyond Athena. Pick OWOX if you're already in their platform. ::: ## Setup with CData Connect Cloud ### Step 1: Configure the CData connection ### Step 2: Connect Looker Studio to CData ### Step 3: Build your first report ## Setup with OWOX connector ### Step 1: Configure the OWOX connection ### Step 2: Connect Looker Studio to OWOX ## Working with Tallyfy data in Looker Studio ### Available data Tallyfy Analytics exports your workflow data as Parquet files[^1] to Amazon S3, which Athena then makes queryable. The data covers: - **Process data** - Workflow instances with status, owner, template name/version, tags, and completion timestamps - **Task data** - Individual tasks within processes including assignments, due dates, and completion status - **Form field data** - Questions and answers collected during workflow tasks - **Member data** - User profiles, roles, activity timestamps, and team assignments ### Visualization ideas Here are popular dashboards Tallyfy customers build: 1. **Process volume trends** - Line charts showing processes launched over time 2. **Completion rate scorecards** - Percentage of on-time completions at a glance 3. **Task duration heatmaps** - Spot bottlenecks by visualizing average task durations 4. **User activity tables** - Leaderboards by completion rate 5. **Form response analysis** - Pivot tables exploring form field data patterns :::caution[Interpreting time metrics] Duration metrics show elapsed calendar time between task assignment and completion - including 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 Speed up your Looker Studio reports: - **Use date range controls** - Don't pull all historical data every time - **Filter at the source** - Apply filters at the data source level, not in individual charts - **Limit table rows** - Show top 10 or 20, not thousands of rows - **Enable caching** - Set data freshness to 12-24 hours (daily updates work fine for most workflow analytics) - **Pre-aggregate in Athena** - Create Athena views to reduce query complexity ## Sharing and collaboration Sharing Looker Studio reports is straightforward: - **View access** - Share report URLs with anyone who needs to see the data - **Edit access** - Let team members modify reports and create new visualizations - **Embed reports** - Add reports to websites or internal portals with iframe embeds - **Schedule emails** - Auto-send report snapshots on a set schedule ## Troubleshooting connection issues If the connection fails, check these in order: - **Verify credentials** - Double-check your Access Key and Secret Access Key (one wrong character breaks everything) - **Check permissions** - Your credentials need `AmazonAthenaFullAccess` and `AmazonS3FullAccess` policies attached - **Validate S3 path** - Confirm your S3 staging directory path matches exactly what Tallyfy provided - **Test in AWS Console** - Run a query in the Athena web console to rule out credential issues - **Check connector status** - Make sure your CData or OWOX subscription is active - **Review region** - Confirm you're using the correct AWS region from Tallyfy Support Still stuck? Contact your connector provider's support team first for connection diagnostics, then reach out to Tallyfy Support if the issue is with your Analytics account. ## Cost considerations | Component | Cost | Notes | |-----------|------|-------| | Looker Studio | **Free** | Unlimited reports and dashboards | | Tallyfy Analytics | Subscription | Contact Tallyfy for pricing | | CData Connect Cloud | Subscription | Check CData for current pricing | | OWOX Connector | **Free** | Free Athena connector | | AWS Query Costs | Pay-per-query | Varies based on data scanned | :::tip[Reducing AWS query costs] Athena charges based on data scanned. Keep costs down by using date range filters, caching report data in Looker Studio, and limiting the columns you query. Tallyfy stores analytics data in Parquet format with Snappy compression, which already reduces the volume of data scanned per query. ::: ## Looker Studio vs enterprise Looker | Feature | Looker Studio | Enterprise Looker | |---------|---------------|-------------------| | **Cost** | Free + connector fee | Subscription-based | | **Setup** | 10-15 min | 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 | [^1]: Columnar storage format built for analytics - queries run faster and storage costs less than CSV - **[Connecting Looker to analytics data](https://tallyfy.com/products/pro/integrations/analytics/looker/how-to-connect-looker-to-tallyfy-data/)**: Looker connects to Tallyfy's workflow analytics data through Amazon Athena in about 15-20 minutes. Install a JDBC driver (for self-hosted instances), configure an Athena connection with AWS Access Key credentials, and query Parquet-formatted process and task data stored in S3 to build LookML models and dashboards. ## Connect Looker to Tallyfy data You can connect Looker to Tallyfy's analytics data through Amazon Athena in about 15-20 minutes. Tallyfy exports your workflow data as Parquet files (with Snappy compression) to S3, and Athena lets Looker query that data directly - so you can build LookML models and dashboards from real process metrics. :::note[Looker vs Looker Studio] This guide covers **Looker** (Google Cloud's enterprise BI platform). For **Looker Studio** (the free visualization tool), see the [Looker Studio connection guide](/products/pro/integrations/analytics/looker/how-to-connect-looker-studio-to-tallyfy-data/) instead. ::: ### Requirements Before you start, confirm you have: - Tallyfy Analytics enabled for your organization (the `analytics_enabled` flag must be active) - Looker access - either self-hosted or Looker Cloud - Admin permissions in Looker to create database connections - Admin access to your machine for driver installation (self-hosted only) - AWS Access Key credentials from Tallyfy Support ## Authentication overview Athena supports two authentication methods. For Looker, you'll want Access Keys. | 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[Two separate credential sets] Tallyfy provisions two credential sets when activating Analytics: - **AWS IAM login** - for the AWS web console only - **Access Key + Secret Access Key** - for connecting Looker and other BI tools Use the Access Keys for Looker. Token-based auth avoids "security token invalid" errors that plague console-credential connections. ::: ## Setup process ### Step 1: Install the JDBC driver (self-hosted Looker only) Using Looker Cloud? Skip ahead - Google pre-installs the Athena drivers. For self-hosted instances: :::note[Driver versions] AWS provides 2.x and 3.x JDBC drivers. The 3.x driver handles large result sets better. Use the latest 3.x unless you have compatibility constraints. ::: ### Step 2: Configure the Looker connection If **Test** fails, the cause is almost always one of three things: the wrong region, an S3 staging path your Access Key can't write to, or a typo in the Secret Key. Check them in that order. :::tip[S3 staging directory] Athena stores query results in this S3 location. Tallyfy Support provides the path when provisioning your Analytics account. Your Access Key needs write permissions to this bucket. ::: ### Step 3: Tune performance settings :::note[Connection pooling] Default is 5 concurrent connections. If Looker is your primary Tallyfy analytics tool, raise this to 10-20. For occasional exploration, 5 is fine. ::: ### Step 4: Set up temp database for PDTs Persistent Derived Tables (PDTs)[^1] cache complex calculations so dashboards load faster: ## Working with Tallyfy data in Looker ### Available data Tallyfy Analytics exports two categories of data to S3 as Parquet files: - **Run analytics** - per-process data including process metadata (blueprint name, status, owner), task details (assignments, completion dates, due dates), form field values (questions and answers), comments, and issue tracking - **Members** - user activity and profile data (email, name, role, login history, status) These are organized per-organization in S3, and Athena tables may present this data across views for processes, steps, form fields, and users. ### Building a LookML model Here's a basic starting point: ### Dashboard ideas Some practical dashboards you can build from Tallyfy data: 1. **Process duration analysis** - find where workflows get stuck (durations show elapsed time, not effort) 2. **Team performance scorecards** - completion rates and average handling times per user 3. **Form data analytics** - spot trends in customer requests or quality issues 4. **Active process monitors** - real-time view of running processes and their current status 5. **SLA compliance tracking** - measure whether tasks complete within target timeframes :::caution[Interpreting time metrics] Duration metrics show elapsed calendar time between task assignment and completion, including 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 The Looker API lets you share insights outside Looker itself: - Embed dashboards 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 A few ways to keep queries fast: - **Aggregate awareness** - pre-calculate common metrics in PDTs - **Incremental PDTs** - only recalculate changed data - **Push filters to Athena** - filter at the query level rather than post-processing in Looker - **Monitor query performance** - use Looker's Query History to find slow queries ## Troubleshooting Connection not working? Check these in order: - Double-check your Access Key and Secret Access Key - one wrong character breaks the connection - Verify the S3 staging directory path is correct and your credentials have write access - Confirm the JDBC driver is installed properly (self-hosted only) - Test that Looker can reach `athena.us-east-1.amazonaws.com` on port 443 - Verify your Tallyfy Analytics subscription is active - Enable debug logging by adding `;LogLevel=DEBUG;LogPath=/tmp/athena_debug.log` to **Additional Params**, then check `/tmp/athena_debug.log` for details Still stuck? Contact Tallyfy Support with the exact error message. [^1]: Looker's caching layer that pre-computes query results and stores them in S3 for faster repeat access ### Sigma - **[Alternatives for spreadsheet-style analytics](https://tallyfy.com/products/pro/integrations/analytics/sigma/alternatives-for-tallyfy-analytics/)**: Sigma Computing can't connect directly to Tallyfy Analytics because it needs persistent database connections that Athena doesn't support. Use alternatives like Power BI, Tableau, or AWS QuickSight, or bridge to Sigma through Snowflake or Redshift. ## Sigma alternatives that work with Tallyfy Analytics Sigma Computing can't connect directly to Tallyfy Analytics because Sigma requires persistent database connections, while Tallyfy Analytics runs on Amazon Athena's serverless, query-by-query model. Several alternatives give you that same spreadsheet-style data exploration though - here's how they compare. ### What makes Sigma different Sigma's core appeal is a spreadsheet interface over live cloud data - Excel-like interaction with real-time queries, collaborative editing, and no-code data manipulation. That's the experience we need to replicate with a tool that actually supports Athena. ## Alternative tools ### Option 1: Power BI with Excel integration Power BI gets you closest to Sigma's spreadsheet experience, and it connects directly to Tallyfy Analytics through Athena ODBC drivers. - **Excel-like grid views** for data exploration and manipulation - **Direct Athena connection** - native connectivity to your Tallyfy Analytics data - **Microsoft tools** - pairs with Excel, Teams, and SharePoint - **Self-service capabilities** - business users can build their own reports **Best for:** Organizations already using Microsoft tools or wanting the closest Sigma alternative. ### Option 2: Tableau Tableau connects to Tallyfy Analytics through Athena and offers data grid views, calculated fields, and drag-and-drop manipulation. It leans more toward visualization than spreadsheets - the learning curve is steeper for business users, but the advanced analytics capabilities are stronger. - **Live Athena connections** for real-time querying - **Calculated fields** for formula-based data transformation - **Enterprise governance** features for larger teams **Best for:** Organizations that need advanced visualization alongside data exploration. ### Option 3: AWS QuickSight If you're already in AWS, QuickSight connects to Athena natively - no drivers to install. It offers SPICE in-memory caching for fast performance, AI-powered insights, and serverless scaling that matches Athena's architecture. - **Native Athena integration** - zero driver configuration - **SPICE in-memory engine** for fast, spreadsheet-like performance - **Serverless scaling** that matches Athena's model - **AI-generated insights** for automatic data discovery **Best for:** AWS-focused organizations that want the simplest setup path. ## Implementation strategies ### Hybrid approach with Excel For maximum adoption, use Power BI as a data gateway to Tallyfy Analytics, then push data into Excel for detailed manipulation. Schedule automated refreshes so Excel always has current data. This uses existing Excel skills while keeping the live connection to your analytics pipeline. ### Data warehouse bridge to Sigma If you really want Sigma itself, bridge the gap with a warehouse Sigma supports. **Snowflake** reads your Tallyfy Analytics Parquet files directly from S3 - no ETL needed. Sigma has a native Snowflake connector, so this gives you the full Sigma experience. Your existing Athena access stays intact. [See our Snowflake setup guide](/products/pro/integrations/analytics/snowflake/). **Amazon Redshift** can access your S3 data through Redshift Spectrum, keeping everything in AWS. Sigma supports Redshift connections natively. Before migrating, compare warehouse costs against your current Athena usage and test query performance with your actual data volumes. ### Custom self-service portal With development resources, you can build a Sigma-like interface directly over Athena - a web frontend with grid components, a backend service querying Athena, caching with Redis or ElastiCache, and CSV/Excel export. This requires a full-stack team and several months of work, but gives you complete control over the experience. ## Choosing the right alternative | Criteria | Power BI | Tableau | QuickSight | Custom | |----------|----------|---------|------------|--------| | **Spreadsheet feel** | High | Medium | Low | High | | **Setup complexity** | Low | Medium | Low | High | | **Advanced analytics** | Medium | High | Medium | Customizable | | **AWS integration** | Medium | Medium | High | High | **Quick decision guide:** If you use Microsoft tools, start with Power BI. If you're all-in on AWS, go with QuickSight. If you need Sigma specifically, bridge through Snowflake. If you need advanced visualizations, pick Tableau. - **[Connection limitations and alternatives](https://tallyfy.com/products/pro/integrations/analytics/sigma/current-connection-limitations/)**: Sigma Computing can't connect directly to Tallyfy Analytics because of an architecture mismatch. Bridge the gap with Snowflake or Redshift Spectrum, or switch to BI tools like Power BI, Tableau, or AWS QuickSight that support Athena natively. ## Why Sigma Computing can't connect to Tallyfy Analytics Sigma Computing can't connect directly to Tallyfy Analytics. The root cause is an architectural mismatch - Sigma requires persistent data warehouse connections, while Tallyfy Analytics runs on AWS Athena's serverless model. These two approaches aren't compatible. ### How the architectures differ Sigma expects an always-on database that maintains open connections, provides dedicated compute, and exposes standard JDBC/ODBC endpoints with persistent session management. That's how traditional data warehouses like Snowflake, Redshift, and BigQuery work - and those are exactly what Sigma supports. AWS Athena works differently. It's a serverless query engine[^1] with no persistent database servers. Compute resources spin up per query, data lives as Parquet files in S3 rather than in database tables, and metadata sits in a separate AWS Glue Data Catalog. There's no always-on connection to maintain. ### Where the connection breaks down The incompatibility shows up in several places: - **Connection persistence** - Sigma keeps database connections alive throughout your analysis session. Athena creates and drops connections per query. - **Driver compatibility** - Sigma's connectors expect traditional warehouse JDBC drivers. Athena has JDBC drivers, but they follow completely different usage patterns. - **Metadata discovery** - Sigma looks for standard database metadata APIs. Athena uses AWS Glue Data Catalog instead - a separate service with different interfaces. - **Query optimization** - Sigma optimizes queries for traditional databases. Athena's query planner works against S3-based data with different optimization rules. ## Workarounds that work ### Option 1: Snowflake bridge (recommended) Snowflake reads your Tallyfy Analytics Parquet files directly from S3 - no ETL or data duplication needed. Then you connect Sigma to Snowflake using its native connector. See our [dedicated Snowflake setup guide](/products/pro/integrations/analytics/snowflake/) for the complete configuration. 1. **Create a Snowflake warehouse** - Ideally in us-west-2 for best performance, since that's where Tallyfy Analytics data is stored 2. **Create an external stage** - Point Snowflake to your Tallyfy Analytics S3 location using your existing AWS credentials 3. **Query directly** - Snowflake reads the Parquet files natively 4. **Connect Sigma** - Use Sigma's native Snowflake connector This approach reads your existing S3 data without duplication, works alongside your existing Athena/Power BI/Tableau connections, and scales automatically. The tradeoff is Snowflake licensing costs (usage-based) and the fact that all fields are stored as STRING, so you'll need to cast types in queries. ### Option 2: Redshift Spectrum bridge If you already have Amazon Redshift, use Redshift Spectrum to query your S3 data directly, then connect Sigma to Redshift using its native connector. 1. **Configure Spectrum** on your existing Redshift cluster to read S3 data 2. **Connect Sigma to Redshift** using the native connector 3. **Query Tallyfy data** through Redshift No data duplication needed, and query performance is strong for complex analytics. You'll need to manage a Redshift cluster, which adds AWS costs. ### Option 3: switch BI tools If you'd rather stick with Athena directly, these tools support it natively: | BI tool | Connection method | Strength | |---------|------------------|----------| | **AWS QuickSight** | Native (no drivers needed) | Built for AWS, serverless, pay-per-use | | **Tableau** | Amazon Athena JDBC driver | Advanced visualizations, enterprise governance | | **Power BI** | Amazon Athena ODBC driver | Excel-like experience, Microsoft tools | All three have dedicated Tallyfy Analytics setup guides available. ### Option 4: custom integration If you have development resources, you can build a bridge using AWS SDKs to query Athena programmatically, transform results, cache them in a Sigma-supported database, and schedule syncs. This gives you full control but requires ongoing development and maintenance. ## Choosing the right approach | Your priority | Best option | |--------------|-------------| | **Keep using Sigma** | Snowflake or Redshift Spectrum bridge | | **Lowest cost** | Power BI or Tableau with Athena directly | | **All-AWS stack** | QuickSight with Athena | | **Full customization** | Custom integration | ### Will Sigma ever support Athena? Possibly. Sigma has been expanding its connector list - they recently added Azure SQL Database and SQL Server 2022. Monitor their product roadmap and submit feature requests if Athena support matters to your team. In the meantime, Power BI and Tableau connect to Tallyfy Analytics without any workarounds. [^1]: A serverless query engine runs SQL queries without provisioning servers - you pay per query rather than for always-on infrastructure ### Powerbi - **[Connect Power BI](https://tallyfy.com/products/pro/integrations/analytics/powerbi/how-to-analyze-tallyfy-workflows-with-power-bi/)**: Connect Power BI to your Tallyfy workflow data through Amazon Athena using an ODBC driver in about 15 minutes. Build dashboards from per-process Parquet files and member tables using Access Key authentication (not IAM credentials) in us-west-2. ## Connecting Power BI to Tallyfy Analytics Connect Power BI to Tallyfy Analytics through Amazon Athena[^1] and build dashboards from your workflow data. The setup takes about 15 minutes. With this connection, you can build interactive dashboards showing bottlenecks and team performance, create metrics tailored to your KPIs, schedule automated reports, and merge Tallyfy data with other business systems like your CRM or ERP. ## Connection architecture Power BI connects to your Tallyfy data through Amazon Athena via an ODBC driver. [Diagram removed for brevity] **What to notice:** - Use Access Key/Secret authentication - IAM credentials cause errors - All connections must use the **us-west-2** region ## Authentication methods When Tallyfy activates your Analytics subscription, you receive two credential sets: | Authentication Method | Description | Use for | |----------------------|-------------|---------| | IAM Username/Password | Web console credentials | AWS web console only | | Access Key/Secret | Token-based authentication | Power BI (recommended) | :::caution[Use Access Key authentication] IAM credentials trigger the error "The security token included in the request is invalid" when used with Power BI. Always use your Access Key and Secret Access Key instead. ::: ## Connection setup ### Requirements - Power BI Desktop installed - Tallyfy Analytics subscription activated - Amazon Athena ODBC driver installed - Access Key credentials provided by Tallyfy ### Step 1: Install the Amazon Athena ODBC driver ### Step 2: Configure the ODBC connection | 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 Athena ## Working with Tallyfy data You're connected. Your Tallyfy Analytics data is organized as: - **Per-process Parquet files** - Each process run is exported as a single flat table. Rows are differentiated by the `type` column: `kick_off_task` (kick-off form data), `process_task` (task-level data), `process_task_data` (form field answers within tasks), and `process_task_comment` (comments). Columns include process metadata (`blueprint_name`, `process_status`, `process_owner`), task details (`process_task_name`, `completed_on`, `due_by`, `user_assigned`), and form field data (`form_field_type`, `question_in_form_field`, `answer_in_form_field`). - **Members table** - User data including `email`, `full_name`, `job_title`, `is_active`, `timezone`, and login activity timestamps. :::caution[Time metrics show elapsed time] Completion times show elapsed calendar 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" ::: ### Configuration notes - You must connect to the **us-west-2** region - other regions won't work - Your workgroup must match your organization ID exactly - The catalog name is always **AwsDataCatalog** (exact capitalization matters) - Use Direct Query mode[^2] for datasets over 1GB - Set up refresh scheduling if you need reports updated automatically ## Video tutorial ## Troubleshooting - Verify you're using the **Access Key and Secret Access Key** - not IAM credentials - The ODBC driver must be the **64-bit** version (32-bit won't work with Power BI Desktop) - Confirm the region is **us-west-2** - Check that your Tallyfy Analytics subscription is active - Restart Power BI Desktop after configuring a new ODBC data source Still stuck? Contact Tallyfy support with the exact error message. [^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 ### Tableau - **[Connecting Tableau to analytics data](https://tallyfy.com/products/pro/integrations/analytics/tableau/how-can-i-connect-tableau-to-my-tallyfy-data/)**: Tallyfy Analytics connects to Tableau Desktop through Amazon Athena in about 15 minutes. Install a JDBC driver and use Access Key credentials to query workflow data like process durations, task completion rates, and form field answers. ## Connect Tableau to your Tallyfy Analytics data Connect Tableau to Tallyfy Analytics through Amazon Athena[^1] in about 15 minutes. Once connected, you can build visual dashboards from your workflow data - process durations, task completion rates, form field answers, and member activity. ### Requirements - Tallyfy Analytics subscription activated for your organization - Tableau Desktop installed - Admin access to your computer (for driver installation) - Access Key credentials from Tallyfy Support ## Authentication overview Tallyfy provisions two separate credential sets for Analytics: | Credential type | Use for | |--------|----------| | IAM Username/Password | AWS web console access only | | Access Key + Secret Access Key | Tableau and other BI tool connections (recommended) | :::caution[Use the right credentials] For Tableau, always use **Access Key + Secret Access Key** - not your IAM console login. Token-based authentication avoids "security token invalid" errors that happen with console credentials. ::: ## Setup process ### Step 1 - Install required drivers :::note[Driver updates] AWS updates their JDBC drivers periodically. Check their documentation for the latest version so you don't hit compatibility issues. ::: ### Step 2 - Configure Tableau connection The **Region** has to match the one in your server endpoint exactly. A mismatch here is the most common reason Sign In fails. ### Step 3 - Access Tallyfy data If the Database dropdown is empty, your Athena user doesn't have permission on that catalog yet. Contact Tallyfy Support rather than picking a different catalog. ## Working with Tallyfy data in Tableau ### Available data Here's what your Tallyfy Analytics data covers: - **Process data** - template names, process status, ownership, and completion progress - **Task data** - assignments, due dates, completion timestamps, and task status per step - **Form field data** - questions, answers, and field types collected during workflows - **Member data** - user profiles, activity timestamps, roles, and login history Each process run is exported as a denormalized dataset - meaning process, task, and form field details are combined into a single flat structure. You won't need complex joins to build dashboards. ### Visualization ideas Common dashboards Tallyfy customers build: 1. **Process duration charts** - identify where workflows get stuck (durations show elapsed time, not effort) 2. **User performance scorecards** - task completion rates and average handling times 3. **Form data trends** - patterns in customer requests or quality submissions 4. **Process status monitors** - current state of active workflows :::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 This video walks through the complete setup: ## Troubleshooting connection issues If your connection fails, check these in order: - Verify your Access Key and Secret Access Key are correct - a single wrong character breaks the connection - Confirm the JDBC driver is in the correct folder (`C:\\Program Files\\Tableau\\Drivers` or `~/Library/Tableau/Drivers`) - Test network connectivity to the Athena endpoint - corporate firewalls sometimes block it - Confirm your Tallyfy Analytics subscription is active - Restart Tableau after installing drivers (it won't detect new drivers otherwise) Still stuck? Contact Tallyfy Support with the exact error message. [^1]: Amazon Athena is a serverless query service that lets BI tools run SQL queries directly against data stored in S3 - **[Troubleshoot issues](https://tallyfy.com/products/pro/integrations/analytics/tableau/how-to-troubleshoot-data-connection-issues-in-tallyfy/)**: Tallyfy Analytics connections through Tableau can break due to wrong credential types or expired keys. Diagnose authentication errors and reconnect data sources using the correct Access Key/Secret Key pair and connection parameters. ## Fixing Tableau connection problems with Tallyfy Analytics Tableau connects to Tallyfy Analytics data through Amazon Athena using JDBC. When that connection breaks, here's how to diagnose and fix it. ### Use the right credentials Tallyfy provides two credential sets when Analytics is activated. Using the wrong one is the most common connection failure. | Credential type | Use for | Common problem | |----------------|---------|----------------| | IAM Username/Password | AWS web console access only | Causes "security token invalid" errors in Tableau | | Access Key/Secret Key | Tableau and all BI tool connections | More reliable - use this one | :::caution[Important] Always use the **Access Key and Secret Access Key** for Tableau connections. IAM console credentials don't work with JDBC-based BI tool connections. ::: ### Authentication errors If you see "The security token included in the request is invalid": ### Missing or broken data source When Tableau can't find a previously working data source: ### Connection that can't be edited If **Edit Connection** is grayed out or unresponsive, remove and recreate the connection: ### Date fields showing wrong types Tallyfy stores timestamps in `Y-m-d H:i:s` format. After reconnecting, date fields like `due_by` and `completed_on` sometimes lose their type mapping. ### Sharing workbooks securely When sharing Tableau workbooks that connect to Tallyfy Analytics: ### Preventing connection issues - Keep Tableau Desktop and JDBC drivers up to date - Run **Test Connection** after driver updates or credential changes - Store your connection settings (endpoint, region, S3 staging directory) in a secure location - Create data extracts as backups for critical dashboards - Schedule regular extract refreshes in Tableau Server/Online Still stuck? Contact Tallyfy Support with the exact error message and a screenshot - that speeds up troubleshooting. - **[Sample Tableau visualizations](https://tallyfy.com/products/pro/integrations/analytics/tableau/sample-tableau-visualizations/)**: Explore 10 ready-to-use Tableau chart types for Tallyfy Analytics data, covering task on-time rates, user timeliness, workload distribution, and more. Download the sample workbook to connect to your own data source. ## Ready-to-use Tableau charts for Tallyfy data Here are 10 Tableau visualizations you can build from Tallyfy Analytics data. Each one answers specific business questions using your process, task, and form field data. :::tip[Elapsed time vs. actual effort] These charts show elapsed time based on task timestamps, including weekends, holidays, and idle periods. For actual effort tracking, see [how to track time spent on tasks](/products/pro/tutorials/how-to/track-time-in-tasks/). ::: ### Time performance #### 1. Task on-time completion rates A pie chart breaking down tasks into on-time vs. late based on due dates and completion timestamps. It's useful for quarterly reviews. ![Task on-time completion rates pie chart](https://screenshots.tallyfy.com/tableau-samples-1.jpg) **Questions this answers:** - What percentage of tasks finish on schedule? - Are our due dates realistic? #### 2. User timeliness comparison A bar chart comparing on-time rates across team members. Spot who consistently hits deadlines, and who might need support. ![User timeliness comparison bar chart](https://screenshots.tallyfy.com/tableau-samples-2.jpg) **Questions this answers:** - Which team members meet deadlines most often? - Who might benefit from workload adjustments or deadline changes? #### 3. Timeliness trend over time Track whether on-time completion is improving or declining week over week. It's helpful for measuring the impact of process changes. ![Timeliness trend over time line chart](https://screenshots.tallyfy.com/tableau-samples-3.jpg) **Questions this answers:** - Is timeliness trending up or down? - Did a specific process change improve performance? ### Workload and activity #### 4. Process ownership distribution See how many processes each user owns. Quickly identify uneven workload distribution. ![Process ownership distribution chart](https://screenshots.tallyfy.com/tableau-samples-4.jpg) **Questions this answers:** - Is process ownership balanced across the team? - Are some users overloaded while others have capacity? #### 5. Task completion by user Count completed tasks per person over any time period. It's built from assignee and completion timestamp data. ![Task completion by user chart](https://screenshots.tallyfy.com/tableau-samples-5.jpg) **Questions this answers:** - Who completes the most tasks? - Is workload distributed evenly? #### 6. Task-specific timeliness A heatmap showing which specific steps in your processes run late most often. Darker colors mean more delays. They're the steps worth redesigning. ![Task-specific timeliness heatmap](https://screenshots.tallyfy.com/tableau-samples-6.jpg) **Questions this answers:** - Which steps consistently cause delays? - Are there steps that need redesigning or clearer instructions? #### 7. Process template usage Shows how often each template gets launched. Identifies your most-used processes and templates that might be candidates for retirement. **Questions this answers:** - Which templates are launched most frequently? - Are there templates that should be retired or consolidated? #### 8. Daily task completion activity A time-series chart of daily task completions. Reveals patterns like Monday spikes or Friday slowdowns. ![Daily task completion activity chart](https://screenshots.tallyfy.com/tableau-samples-7.jpg) **Questions this answers:** - Are there day-of-week patterns in task completion? - Do we see consistent throughput or significant fluctuations? ### Process quality #### 9. Comment frequency analysis High comment volume on specific tasks usually signals confusion. This chart pinpoints which steps generate the most discussion. ![Comment frequency analysis chart](https://screenshots.tallyfy.com/tableau-samples-8.jpg) **Questions this answers:** - Which tasks need the most clarification? - Where should you improve step instructions or documentation? #### 10. Issue frequency by task Ranks tasks by how often they generate reported issues. Fix the top offenders first for the biggest improvement. ![Issue frequency by task chart](https://screenshots.tallyfy.com/tableau-samples-9.jpg) **Questions this answers:** - Which tasks consistently produce problems? - Where should process improvement efforts focus first? ## Download the sample workbook Get started quickly by downloading a pre-built Tableau workbook: 1. Download the [sample Tableau workbook](https://screenshots.tallyfy.com/SAMPLE-WORKBOOK---Athena.zip) 2. Open it in Tableau Desktop 3. Click **Edit Connection** and point it to your Tallyfy Analytics data source 4. Customize the visualizations for your needs ![Sample Tableau workbook overview](https://screenshots.tallyfy.com/tableau-samples-10.jpg) These 10 charts are starting points. Once you've connected to Tallyfy Analytics, you can build custom views for any question your workflow data can answer. - **[Share a Tableau workbook](https://tallyfy.com/products/pro/integrations/analytics/tableau/share-workbook-without-data/)**: Tableau workbooks connected to Tallyfy Analytics can be safely shared by disconnecting data sources before distribution so recipients get the full dashboard layout and visualizations but must reconnect using their own credentials to protect your data and access details. ## Sharing Tableau workbooks without exposing Tallyfy data Disconnect your Tallyfy Analytics data sources before sharing a Tableau workbook. Recipients get all your visualizations and dashboard layouts, but they'll connect their own credentials. Your connection details stay private. ### Sharing methods at a glance | Method | Best for | Data protection | |--------|----------|-----------------| | Data source disconnection | One-time sharing | Medium - structure visible, data removed | | Filtered data extract | Recurring sharing | High - only selected data included | | Tableau Server / Tableau Cloud | Team collaboration | High - centralized permission control | | PDF/PNG export | Quick, read-only sharing | Complete - no data connectivity at all | ### Before you start - Tableau Desktop installed - Working Tallyfy Analytics connection in Tableau - Visualizations and dashboards already built ## Method 1: Disconnect data sources This approach strips your data while preserving the workbook structure. Recipients reconnect with their own credentials. ### Prepare your workbook Confirm your Tableau workbook contains all the visualizations and dashboards you want to share. ![Tableau workbook with Tallyfy Analytics visualizations](https://screenshots.tallyfy.com/tableu-share-workbook-1.png) ### Disconnect the data sources Alternatively, you can redirect the connection instead of closing it: ### Save and share ### What recipients see when they open it Recipients will see connection errors when they open the workbook - that's expected: ![Tableau connection error when opening shared workbook](https://screenshots.tallyfy.com/tableu-share-workbook-7.png) They can click to see full error details: ![Tableau full error details for disconnected data source](https://screenshots.tallyfy.com/tableu-share-workbook-8.png) To reconnect their own data: ## Fixing data types after reconnection After reconnecting, date fields like `due_by` and `completed_on` sometimes need their data types reset. This takes about two minutes: ## Other sharing methods ### Method 2: Share a filtered data extract Don't want to share everything? Create a filtered extract with just the data you need: ### Method 3: Publish to Tableau Server or Tableau Cloud For enterprise-grade sharing with role-based access control: ### Method 4: Export as PDF or PNG For a quick, read-only share with no data connectivity: ## Best practices - Remove unnecessary sheets and dashboards before sharing - Document which data sources recipients need and how to connect - Test the reconnection process yourself before sending - Strip out sensitive calculations or parameters - Consider including sample data so recipients can verify the layout works ### Business systems - **[EOS integration and process component support](https://tallyfy.com/products/pro/integrations/business-systems/eos-integration/)**: Tallyfy turns your documented EOS processes into trackable workflows that run consistently every day. Teams get real-time visibility into who has what by when, so Level 10 Meetings and scorecards use actual execution data instead of guesswork. ## Using Tallyfy with EOS implementations Tallyfy fills the execution gap in EOS implementations - the Process Component that gets neglected while everyone focuses on strategy and scorecards. Companies nail their quarterly planning, hire great people, and track data religiously, but their processes stay stuck in people's heads. Tallyfy takes your documented EOS processes and makes them run. Every day. Consistently. ### The EOS Process Component challenge The Process Component gets the least attention. That's a common frustration among EOS Implementers. - **Vision and Traction** components get quarterly planning sessions and retreats - **People and Data** components are tackled through hiring strategies and scorecard meetings - **Process Component** sits gathering dust on a shared drive - **Issues Component** can't work properly when processes aren't actually running The result? Your team does things differently every time. New hires struggle without clear guidance. Accountability falls apart when nobody knows who should do what. ### How Tallyfy complements EOS methods 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 - **Document**: Turn EOS process documents into living Tallyfy [templates](/products/pro/documenting/templates/) - **Track**: Watch [processes](/products/pro/tracking-and-tasks/processes/) run in real-time (no more guessing who's doing what) - **Improve**: Get actual data on bottlenecks and fix them #### Working with EOS tools - **EOS ONE Software**: Use Tallyfy for process execution while keeping 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 #### Supporting EOS roles - **Integrator role**: Gain visibility into operational execution and bottlenecks - **Visionary role**: Focus on strategy while processes run consistently - **EOS Implementer**: Give clients tactical process execution capabilities ### Specific EOS process challenges Tallyfy solves #### Tribal knowledge documentation You've seen it happen - Sarah from accounting leaves, and suddenly nobody knows how to process vendor payments. With Tallyfy: - Every process step is captured and available to the whole team - New team members follow step-by-step instructions without hand-holding - Your processes survive when people move on #### Process standardization and consistency EOS talks about doing things "the right way, every time." Hard to do without the right tool: - Every team member follows the exact same steps (yes, even that one person who "has their own system") - [Tasks](/products/pro/tracking-and-tasks/tasks/) route automatically to the right people - Deadlines and accountability are built in #### Sales-to-operations handoff Your CRM shows "Closed Won" but operations is scrambling. Dozens of micro-tasks between sales closing and successful delivery get lost. Tallyfy orchestrates these handoffs: - Implementation kickoff checklist across multiple 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. #### 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 EOS consultants and implementers can use Tallyfy #### For EOS Implementer professionals - **Client differentiation**: 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 coaching sessions #### For internal EOS champions - **Leadership support**: Show your leadership team real progress, not slide decks - **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 ### Implementation approach for EOS companies #### Phase 1 - foundation (document) Start small. Pick 2-3 processes that cause friction right now: - Convert them into Tallyfy templates (takes about 30 minutes each) - Use the same language your EOS docs use for consistency #### Phase 2 - execution (track) - Launch your processes and watch them run - Add process completion rates to your scorecards - Train your team once - they'll pick it up fast #### 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 Keep using EOS ONE for strategic planning while Tallyfy handles daily execution: - Export process metrics 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 tell the whole story: - Track how many processes complete on time - Monitor cycle times month after month - Connect process health directly to business results When you combine EOS's proven system with Tallyfy's execution capabilities, the Process Component stops being the weak link and starts driving real results. ### Byo ai - **[ChatGPT integration](https://tallyfy.com/products/pro/integrations/byo-ai/chatgpt-integration/)**: ChatGPT users on Plus or higher plans can connect to Tallyfy's MCP server using OAuth 2.1 with PKCE. Search and manage tasks, processes, templates, and automations through plain language with over 30 available tools. :::note[Integration status] This integration is live. You connect ChatGPT to Tallyfy's secure server, sign in with your normal Tallyfy account, and it works with ChatGPT's Apps and Connectors feature. ::: :::tip[Prefer a no-setup option?] Tallyfy also publishes a free [Process Documentation AI](https://chatgpt.com/apps/process-documentation-ai/asdk_app_6a02832083a48191929828b6c48d4ee9) app in the ChatGPT app directory. It needs no Tallyfy account or connection setup. Describe a process and it returns a structured procedure with a downloadable Word document you can import into Tallyfy. ::: ## Run Tallyfy workflows from ChatGPT Connect ChatGPT to Tallyfy and you can run your work by just asking. Type what you want in plain English, and ChatGPT does it in Tallyfy: show your open tasks, start a process, check where something stands, or tidy up a template. No code. No API keys. You sign in once with your normal Tallyfy account, and ChatGPT handles the rest. The setup takes a few minutes and you do it once. After that, you just chat. ### Set up the connection ## What you can ask ChatGPT to do Once you're connected, you talk to Tallyfy in plain language. ChatGPT picks the right action behind the scenes. You can ask it to: - **Find and create tasks** - list your tasks, a teammate's tasks, or every task in a process, and create a new task from a sentence (it picks out the title, deadline, and who to assign). - **Search** - find tasks, running processes, or templates by keyword. - **Check process status** - see how far a running process has gone and what step it's on. - **Read and build templates** - pull up a template, add steps, set who's assigned, edit instructions, and get suggestions for deadlines and kick-off fields. - **Manage form fields** - add, update, reorder, or remove fields on a step, and edit dropdown choices. - **Set up automations** - create, change, delete, and review the if-then rules on a template, with suggestions for cleaning up duplicates and conflicts. - **Manage people** - list your members and guests, and invite someone new by email. - **Get advice** - ask ChatGPT to review a template's health or suggest improvements. There are more than 30 of these actions in total. The full list, with exact names, is in the [For developers](#for-developers) section below. **You're always in control of changes.** Before ChatGPT creates, updates, or deletes anything, it shows a confirmation box. Nothing changes in Tallyfy until you approve it. ## Real examples Here's the kind of thing people ask, and what ChatGPT does with it: - **"Show me all urgent tasks assigned to the sales team."** ChatGPT searches your tasks and returns a filtered list with the details. - **"What's the status of the employee onboarding process for John Smith?"** ChatGPT finds the process and reports how complete it is and which step it's on. - **"Analyze our Customer Onboarding template and suggest improvements."** ChatGPT pulls the template, checks its health, reviews the automations, and summarizes what to fix. - **"Get all my tasks and tell me which ones are overdue."** ChatGPT gathers your tasks, checks the due dates, and gives you an organized summary. - **"Add a rule to the Sales template that assigns the contract review step to Sarah when a deal is over $50,000."** ChatGPT finds the step, sets up the rule, and creates it after you approve. - **"Find our onboarding template, show me the active runs, and tell me which form fields people leave empty most often."** ChatGPT chains several lookups together and summarizes the pattern for you. ## Tips for better questions The clearer your request, the better the answer: - **Be specific.** "Find tasks with 'invoice approval' in the title assigned to me" beats "show tasks". - **Add context for filtering.** "Get processes from the Customer Onboarding template created in the last 7 days" beats "find recent processes". - **Say exactly what to change.** "Add 'Critical' to the Priority dropdown in the Bug Report template" beats "change the priority field". - **Ask for the shape you want.** "List my tasks grouped by due date, showing only title and assignee" gives you a tidy summary instead of a wall of text. ## What ChatGPT can't show or do ChatGPT is text, so a few things stay in Tallyfy itself: - **Visual views.** ChatGPT can't draw Tallyfy's process tracker or workflow diagrams. For step flows, progress bars, and dependencies at a glance, use the [tracker view](/products/pro/tracking-and-tasks/tracker-view/) in Tallyfy. - **Complex form fields.** Dropdowns with lots of options, date pickers, and file uploads don't translate well to plain text. File attachments can't be handled at all. - **Live updates.** ChatGPT won't notify you when a teammate changes something. You'll see their changes the next time you ask. - **Bulk visual work.** Drag-and-drop reordering, batch update previews, and visual branching stay in Tallyfy's normal interface. ## Keeping your data safe - **Secure sign-in.** You authorize access with your Tallyfy login. No passwords or API keys get passed around. - **You control what it can touch.** Access is split into separate read and write permissions across tasks, processes, templates, forms, users, and automations. - **Changes need your approval.** ChatGPT shows a confirmation box before any create, update, or delete. - **Revoke anytime.** OpenAI stores your sign-in securely, and you can disconnect from ChatGPT **Settings** > **Connectors** whenever you want. - **No training on your data.** OpenAI doesn't use these interactions to train its models, per their usage policies. - **Watch for prompt injection.** If a task or template contains text that reads like instructions, be careful and double-check anything ChatGPT does that looks unexpected before you act on it. ## Troubleshooting **ChatGPT can't find the Tallyfy connector** - Check that Developer Mode is on: **Settings** > **Apps and Connectors** > **Advanced Settings**. - Confirm your ChatGPT plan supports Apps and Connectors (Plus, Pro, Team, Enterprise, or Education). - Re-create the connector with the correct URL: `https://mcp.tallyfy.com`. **Sign-in fails or keeps looping** - Reconnect from **Settings** > **Connectors** > **Tallyfy** > **Reconnect**. - Confirm your Tallyfy account is active with at least a Standard role. - Clear your browser cache and try again. (To check the server itself is reachable, see [For developers](#for-developers).) **ChatGPT says it can't use certain tools** - Make sure you approved every permission when you first connected. - Some changes need an Administrator role in Tallyfy. - Disconnect and reconnect to ask for all permissions again. **Search comes back empty** - Make the request more specific - a search needs at least one keyword. - Confirm the items exist in your workspace and that your account is allowed to see them. ## What it costs Your ChatGPT subscription covers this: - **ChatGPT Plus**: $20/month - works through Developer Mode, for individual use. - **ChatGPT Pro**: $200/month - higher rate limits and priority access. - **ChatGPT Team**: $25/user/month - workspace sharing and admin controls. - **ChatGPT Enterprise or Education**: custom pricing - admin-managed apps and extra security. Tallyfy doesn't charge anything extra for this. Every request ChatGPT makes does count toward your normal Tallyfy API rate limits, so specific questions (rather than broad ones) keep things fast. ## For developers *(Skip this unless you're setting up the technical side.)* The Tallyfy MCP server at `https://mcp.tallyfy.com` uses OAuth 2.1 with PKCE[^1]. ChatGPT discovers the endpoints automatically through the `/.well-known` URLs, so you don't configure them by hand. Tallyfy issues the tokens; OpenAI stores the refresh token securely, and it's revocable anytime. Use Streamable HTTP transport - SSE is no longer supported. ### OAuth endpoints ChatGPT auto-discovers these. You only need them for debugging or a custom client. | Endpoint | URL | |---|---| | MCP server | `https://mcp.tallyfy.com` | | Protected resource metadata (RFC 9728) | `https://mcp.tallyfy.com/.well-known/oauth-protected-resource` | | Authorization server metadata (RFC 8414) | `https://mcp.tallyfy.com/.well-known/oauth-authorization-server` | | Authorization (proxy) | `https://mcp.tallyfy.com/mcp/oauth/authorize` | | Token exchange (proxy) | `https://mcp.tallyfy.com/mcp/oauth/token` | | Client registration (proxy) | `https://mcp.tallyfy.com/mcp/oauth/register` | | Tallyfy auth server | `https://account.tallyfy.com` | ### Permission scopes ChatGPT requests all 12 of these during authorization. | Scope | Access | |---|---| | `mcp.tasks.read` | Search and retrieve task data | | `mcp.tasks.write` | Create and update tasks | | `mcp.processes.read` | View workflow process status | | `mcp.processes.write` | Manage process lifecycle | | `mcp.templates.read` | Read template configurations | | `mcp.templates.write` | Edit templates, steps, and automations | | `mcp.forms.read` | View form field definitions | | `mcp.forms.write` | Add and update form fields | | `mcp.users.read` | View users and guests | | `mcp.users.write` | Invite and manage users | | `mcp.automation.read` | View automation rules | | `mcp.automation.write` | Create and modify automations | ### Full list of MCP tools **Task tools** - `get_my_tasks` - Get all tasks assigned to the current user (no parameters needed) - `get_user_tasks` - Get tasks assigned to a specific team member by user ID - `get_tasks_for_process` - Get all tasks in a specific process by ID or name - `create_task_from_text` - Create a task from natural language - extracts title, deadline, and assigns to named members or guests **Search tools** - `search_for_tasks` - Search tasks across the organization by keyword - `search_for_processes` - Search workflow processes/runs by keyword - `search_for_templates` - Search templates by keyword (use `get_all_templates` for a full list) **Process tools** - `get_organization_runs` - Get all workflow processes with optional filters for status, template, owner, tags, and type **Template tools** - `get_template` - Get a template by ID or name with full details - `get_all_templates` - Get all templates in the organization - `get_kickoff_fields` - Get kick-off form fields for a template - `get_step_dependencies` - Analyze which automations control when a step appears - `assess_template_health` - Retrieve full template data so the AI can assess the template's health - `suggest_step_deadline` - Get deadline recommendations for a step - `suggest_kickoff_fields` - Get suggested kick-off fields based on template content - `add_step_to_template` - Add a new step to an existing template - `add_assignees_to_step` - Add member or guest assignees to a step - `edit_description_on_step` - Update the description/instructions on a step **Form field tools** - `add_form_field_to_step` - Add text, dropdown, date, or other field types to a step - `update_form_field` - Update an existing form field's properties - `move_form_field` - Reorder a form field within a step - `delete_form_field` - Remove a form field from a step - `get_dropdown_options` - Get the options for a dropdown field - `update_dropdown_options` - Update dropdown choices - `suggest_form_fields_for_step` - Get AI recommendations for useful form fields based on step content **Automation tools** - `create_automation_rule` - Create if-then automation rules on a template - `update_automation_rule` - Modify an existing automation rule's conditions or actions - `delete_automation_rule` - Remove an automation rule - `analyze_template_automations` - Analyze all automations with redundancy detection (duplicates, same-trigger groups) - `get_step_visibility_conditions` - See which automations control a step's visibility with actual condition details - `suggest_automation_consolidation` - Get prioritized recommendations for consolidation (orphaned rules, duplicates, conflicts, merge candidates) **User and guest tools** - `get_organization_users` - Get all organization members with profile data - `get_organization_users_list` - Get members with minimal data for listing - `get_organization_guests` - Get guest users with full data - `get_organization_guests_list` - Get guests with minimal data - `invite_user_to_organization` - Invite a new member by email ### Checking the server and connection errors To confirm the server is reachable, open `https://mcp.tallyfy.com/.well-known/oauth-protected-resource` in a browser. A JSON response means it's up. If you hit SSE connection errors, that's expected: SSE transport is no longer supported. The server uses Streamable HTTP only, and recent ChatGPT versions default to it, so update ChatGPT if you're on an old build. [^1]: OAuth 2.1 with PKCE is a secure sign-in standard that authorizes access with tokens instead of sharing your password or an API key. - **[Claude integration](https://tallyfy.com/products/pro/integrations/byo-ai/claude-integration/)**: Claude connects to Tallyfy's MCP server at mcp.tallyfy.com using OAuth 2.1 with PKCE. Manage tasks, processes, templates, and automations through natural language in Claude.ai or Claude Desktop with over 40 tools. ## Connect Claude to Tallyfy Connect Claude to Tallyfy and you can manage your work just by chatting. Ask Claude about your tasks, launch a process, or clean up a template, and it does the work in your Tallyfy account for you. It works in both Claude.ai on the web and the Claude Desktop app, on any paid Claude plan. You connect once by adding Tallyfy as a connector in Claude's settings, then signing in with your Tallyfy account. Claude takes it from there. The exact steps for the web app and the desktop app are under [For developers](#for-developers). ### What you can do Once it's connected, you talk to Claude in plain language and it works in Tallyfy for you. Claude can: - **Handle your tasks** - find your open tasks, create new ones from a sentence, update them, and mark them done. - **Run and track processes** - launch a workflow from a template, check on running work, and archive what's finished. - **Build and tidy templates** - read a template, add steps, suggest deadlines and form fields, and check a template's health for problems. - **Manage form fields and automation rules** - add or change fields, and create or clean up the if-then rules that drive your workflows. - **Work with comments and people** - read and add task comments, and look up or invite team members and guests. ### How to connect The setup is quick. In Claude's settings, open **Connectors** (or **Integrations** in the desktop app), add a custom connector named Tallyfy pointing at the Tallyfy MCP server[^1], and sign in with your Tallyfy account to authorize it. Add it once and it syncs across Claude on the web, desktop, and mobile. Step-by-step clicks for both apps are under [For developers](#for-developers). ### What it costs You need a paid Claude plan (Pro, Max, Team, or Enterprise). There's no extra Tallyfy charge for using this, but the tool calls count toward your Anthropic usage limits. ### Is it secure? Yes. Anthropic doesn't train on your data. The Claude Desktop app stores your sign-in token in your computer's secure keychain (macOS Keychain or Windows Credential Manager), never in plain text. Each organization's data stays separate, every interaction is logged for audit, and Anthropic maintains SOC 2 Type II compliance. The sign-in detail is under [For developers](#for-developers). ## For developers *(Skip this unless you're setting up the technical side.)* The integration is live. The Tallyfy MCP server at `https://mcp.tallyfy.com` supports OAuth 2.1 with PKCE. Use Streamable HTTP transport - SSE is no longer supported. Both Claude.ai (web) and Claude Desktop connect through it, and the connection uses OAuth 2.1 with PKCE[^2] - Claude handles the auth flow automatically when you add the server URL. ### Set up Claude.ai (web) Available on paid Claude plans (Pro, Max, Team, Enterprise). Once added, the connector syncs across Claude web, Claude Desktop, and Claude Mobile. ### Set up Claude Desktop Available on paid Claude plans (Pro, Max, Team, Enterprise). Download for macOS or Windows. ### How the integration works Tallyfy's MCP server runs on Cloudflare at `https://mcp.tallyfy.com` and exposes your Tallyfy data as tools Claude can call during a conversation. The flow works like this: 1. **Tool discovery** - Claude connects and queries the MCP server for available tools 2. **OAuth 2.1 authentication** - Claude handles the auth flow. You sign in with Tallyfy credentials and authorize access 3. **Tool calls** - When you ask a question, Claude picks the right Tallyfy tool and passes the correct parameters 4. **API execution** - The MCP server uses your credentials to call the Tallyfy API and returns structured results 5. **Response** - Claude formats the data into a natural language answer ### Authentication architecture The MCP server uses OAuth 2.1 with PKCE (S256). All discovery and token exchange happens through `https://mcp.tallyfy.com`, which proxies to Tallyfy's authorization server: | Endpoint | URL | |---|---| | MCP server | `https://mcp.tallyfy.com` | | Protected resource metadata | `https://mcp.tallyfy.com/.well-known/oauth-protected-resource` | | Authorization server metadata | `https://mcp.tallyfy.com/.well-known/oauth-authorization-server` | | Authorization (proxy) | `https://mcp.tallyfy.com/mcp/oauth/authorize` | | Token exchange (proxy) | `https://mcp.tallyfy.com/mcp/oauth/token` | | Client registration (proxy) | `https://mcp.tallyfy.com/mcp/oauth/register` | | JWKS (token verification) | `https://mcp.tallyfy.com/.well-known/jwks.json` | **Supported OAuth scopes**: | Scope | Access | |---|---| | `mcp.tasks.read` | Read tasks and assignments | | `mcp.tasks.write` | Create, update, and complete tasks | | `mcp.processes.read` | Read workflow runs | | `mcp.processes.write` | Launch, update, and archive processes | | `mcp.templates.read` | Read templates and steps | | `mcp.templates.write` | Edit templates, steps, and automations | | `mcp.forms.read` | Read form fields | | `mcp.forms.write` | Add and modify form fields | | `mcp.users.read` | Read organization members and guests | | `mcp.users.write` | Invite and manage users | | `mcp.automation.read` | Read automation rules | | `mcp.automation.write` | Create and modify automations | ### MCP server tools The Tallyfy MCP server exposes these tools to Claude: **Task tools** - `get_my_tasks` - Get all tasks assigned to the current user - `get_user_tasks` - Get tasks for a specific team member by user ID - `get_tasks_for_process` - Get all tasks in a specific process by ID or name - `create_task_from_text` - Create a task from natural language - extracts title, deadline, and assigns to named members or guests - `complete_task` - Mark a task as complete - `reopen_task` - Reopen a previously completed task - `update_task` - Update task properties like title, deadline, or description **Search tools** - `search_for_tasks` - Search tasks across the organization by keyword - `search_for_processes` - Search workflow processes/runs by keyword - `search_for_templates` - Search templates by keyword (use `get_all_templates` for a full list) **Process tools** - `get_organization_runs` - Get all active workflow processes with optional filters for status, template, owner, tags, and type - `launch_process` - Launch a new process from a template with a name, optional tags/folders, and optional `prerun` values to pre-fill the kick-off form. The `prerun` object is keyed by each kick-off field's timeline ID (a 32-character hex string), not by the field's label or alias. Claude gets those IDs from `get_kickoff_fields`, so let it make that call rather than supplying field names yourself - `get_process` - Get details for a specific process by ID - `update_process` - Update process properties like name or tags - `archive_process` - Archive a completed or cancelled process **Template tools** - `get_template` - Get a template by ID or name with full details - `get_all_templates` - Get all templates in the organization - `get_template_steps` - Get all steps for a template - `get_kickoff_fields` - Get kick-off form fields for a template - `get_step_dependencies` - Analyze which automations control when a step appears - `assess_template_health` - Retrieve complete template data for a full health assessment by the AI - `suggest_step_deadline` - Get deadline recommendations for a step based on its type and complexity - `suggest_kickoff_fields` - Get suggested kick-off fields based on template content - `add_step_to_template` - Add a new step to an existing template - `add_assignees_to_step` - Add member or guest assignees to a step - `edit_description_on_step` - Update the description/instructions on a step - `update_template` - Update template properties like title or description - `clone_template` - Create a copy of an existing template with a new name **Form field tools** - `add_form_field_to_step` - Add text, dropdown, date, or other field types to a step - `update_form_field` - Update an existing form field's properties - `move_form_field` - Reorder a form field within a step - `delete_form_field` - Remove a form field from a step - `get_dropdown_options` - Get options for a dropdown field - `update_dropdown_options` - Update dropdown choices - `suggest_form_fields_for_step` - Get AI recommendations for useful form fields based on step content **Automation tools** - `create_automation_rule` - Create if-then automation rules on a template - `update_automation_rule` - Modify an existing automation rule's conditions or actions - `delete_automation_rule` - Remove an automation rule - `analyze_template_automations` - Analyze all automations with redundancy detection (duplicates, same-trigger groups) - `get_step_visibility_conditions` - See which automations control a step's visibility with actual condition details - `suggest_automation_consolidation` - Get prioritized recommendations for consolidation (orphaned rules, duplicates, conflicts, merge candidates) **Comment tools** - `get_task_comments` - Get all comments on a specific task - `add_task_comment` - Add a comment to a task **User and guest tools** - `get_organization_users` - Get all organization members with profile data - `get_organization_users_list` - Get members with minimal data for listing - `get_organization_guests` - Get guest users with full data - `get_organization_guests_list` - Get guests with minimal data - `invite_user_to_organization` - Invite a new member by email **Organization tools** - `get_groups` - Get groups in the organization - `get_folders` - Get folders for organizing templates and processes - `get_tags` - Get tags used across the organization ### Example prompts **Template health audit** ```text Prompt: "Assess the health of our Customer Onboarding template and suggest improvements to the automation rules." Claude calls: assess_template_health -> analyze_template_automations -> suggest_automation_consolidation, then summarizes findings and recommended fixes. ``` **Process launch and tracking** ```text Prompt: "Launch the Employee Onboarding template for Jane Doe and show me all the tasks that were created." Claude calls: launch_process -> get_tasks_for_process, then lists every task with assignees and deadlines. ``` **Writing effective prompts for Claude** Be specific about what you want analyzed and how you want the output structured: ```text 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." ``` Give Claude explicit reasoning steps: ```text Good: "First, identify all people 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." ``` ### Security and compliance - **No training on your data** - Anthropic doesn't train on API inputs - **JWT validation** - Tokens validated via RS256 using Tallyfy's public key. Only Tallyfy can issue valid tokens - **OS keychain storage** - Claude Desktop stores tokens in macOS Keychain or Windows Credential Manager, never in plaintext - **Data isolation** - Each organization's data stays separate - **Audit logging** - Complete interaction history - **SOC 2 Type II** - Anthropic maintains compliance ### Troubleshooting **"MCP tools icon doesn't appear"** - Restart Claude Desktop completely (Cmd+Q on macOS, not just closing the window) - Check **Settings** - then **Integrations** to confirm `https://mcp.tallyfy.com` is listed and active - If the server shows an error, remove and re-add it **"Authorization fails or loops"** - Confirm you're signing in with the Tallyfy account that has access to the target organization - Open `https://mcp.tallyfy.com/.well-known/oauth-protected-resource` in your browser - a JSON response means the server is reachable - Clear Claude Desktop's stored credentials and re-authorize from scratch **"SSE connection errors"** - SSE transport isn't supported anymore. The Tallyfy MCP server uses Streamable HTTP only - Update Claude Desktop to the latest version, which defaults to Streamable HTTP ### Best practices 1. **Start with read-only tools** - Use `get_my_tasks`, `search_for_processes`, and `get_all_templates` first to get familiar with the data before running write operations 2. **Be specific** - Name the template, process, or user explicitly. Claude performs best with complete context 3. **Add human checkpoints** - For write operations like creating automation rules, review Claude's plan before confirming 4. **Iterate on prompts** - Review Claude's outputs and refine your instructions over time [^1]: Model Context Protocol - Anthropic's open standard letting AI models call external tools and access data securely [^2]: Proof Key for Code Exchange - prevents authorization code interception attacks during the OAuth flow - **[Microsoft Copilot integration](https://tallyfy.com/products/pro/integrations/byo-ai/microsoft-copilot-integration/)**: Connect Microsoft 365 Copilot to Tallyfy through API plugins and Azure AD OAuth2. Copilot reads your emails, documents, and Teams data to trigger and manage workflow automation. ## What this integration does Microsoft 365 Copilot can connect to Tallyfy through API plugins and enterprise OAuth2. This brings your Microsoft tools - emails, documents, Teams conversations, SharePoint data - into workflow automation while respecting your organization's security policies. ### How it works The integration uses Microsoft's API plugin system 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 reads your Microsoft 365 data with scoped permissions 4. **Declarative agents** - Configure Copilot agents for specific workflow scenarios Copilot already knows your organization's context - who works on what, document history, communication patterns - so it's well-suited for enterprise workflows. ### Authentication and security Microsoft Copilot uses 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` Enterprise security features apply automatically: - Conditional access policies - Multi-factor authentication - Sensitivity labels - Data loss prevention rules - Compliance boundaries ### Using Microsoft 365 context #### Email-driven automation Copilot can read 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 can analyze SharePoint and OneDrive files: ``` Scenario: Policy Update Process Copilot action: Compares new policy version with previous, identifies 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 assigned tasks, sets deadlines from mentioned dates, links to Teams channel. ``` ### Declarative agent configuration You can 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. knowledge: - SharePoint: /sites/Sales/Templates - Teams: Sales Team Channel actions: - Create Tallyfy process - Assign tasks by territory - Generate documents ``` **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. Maintain compliance audit trail. knowledge: - SharePoint: /sites/HR/Policies - Teams: HR Support Channel actions: - Create employee processes - Route hierarchical approvals - Generate HR documents ``` ### Microsoft Graph API integration Copilot accesses your organization's data through Graph API: **Available data sources**: - User profiles and org hierarchy - Calendar availability and meeting details - Email content and attachments - SharePoint documents and lists - Teams messages and files - OneDrive files - Planner tasks **Example API calls**: ```javascript // Get manager for approval routing GET https://graph.microsoft.com/v1.0/users/{id}/manager // Create Teams meeting for process review POST https://graph.microsoft.com/v1.0/me/onlineMeetings // Access SharePoint template GET https://graph.microsoft.com/v1.0/sites/{site}/drive/items/{id} ``` ### Power Platform connectivity You can extend Copilot with Power Platform: - **Power Automate** - Trigger multi-system workflows, connect to 1000+ services, handle approvals - **Power Apps** - Embed custom forms in tasks, create mobile interfaces, access on-premises data - **Power BI** - Generate workflow analytics, create dashboards, track KPIs ### Compliance and governance **Information protection**: - Sensitivity labels apply to generated content - Encryption for data at rest and in transit - Rights management for documents **Audit and monitoring**: - All Copilot actions logged in audit trail - Compliance center visibility - Alert policies for unusual activity - eDiscovery support **Data residency**: - Respects geographic boundaries - Complies with regional regulations - Supports government clouds ### Performance tips - Cache frequently accessed data to reduce API calls - Batch Graph API requests where possible - Use delta queries for change detection - Implement webhook subscriptions for real-time updates - Respect Graph API throttling limits with exponential backoff ### Troubleshooting **"Copilot can't access Tallyfy"** - Verify API plugin installation in admin center - Check Azure AD app permissions - Review conditional access policies - Ensure the user has a Copilot license **"Data isn't syncing correctly"** - Check Graph API permissions - Verify sensitivity labels allow access - Review data loss prevention rules ### Licensing requirements - Microsoft 365 E3 or E5 - Copilot for Microsoft 365 (check Microsoft for current pricing) - Tallyfy subscription - Optional: Power Platform licenses ### 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 a declarative agent for your use case 4. **Test integration** - Run a pilot with a single workflow 5. **Roll out** - Deploy to all users with training - **[Use cases](https://tallyfy.com/products/pro/integrations/byo-ai/use-cases/)**: Connect any major AI platform to Tallyfy through MCP to manage tasks, check process status, build templates, launch workflows, and generate reports through natural conversation. No API expertise or tab-switching needed. ## What you can actually do with AI connected to Tallyfy Once your AI assistant is connected to Tallyfy through MCP, you unlock a practical set of things you can do through conversation - no API knowledge needed, no copy-pasting between tabs. These articles show you how to put that connection to work. All major platforms work: Claude, ChatGPT, Microsoft Copilot, and Gemini. ## Browse by category ### Getting started **[Connect your AI to Tallyfy](/products/pro/integrations/byo-ai/use-cases/connect-your-ai-to-tallyfy/)** - One-time setup that works for any major AI platform. Do this first and the rest of the articles become possible. ### Daily work Articles here cover the things you might do every single day - quick status checks and routine lookups that would otherwise require opening multiple tabs. **[Get a daily briefing of your tasks](/products/pro/integrations/byo-ai/use-cases/get-a-daily-briefing-of-your-tasks/)** - Ask your AI what's due, what's overdue, and what needs your attention today - all in one response. **[Check process status across your team](/products/pro/integrations/byo-ai/use-cases/check-process-status-across-your-team/)** - See where any running process stands, which steps are stuck, and who's holding things up. **[Find anything across your workflows](/products/pro/integrations/byo-ai/use-cases/find-anything-across-your-workflows/)** - Search tasks, processes, and templates using plain descriptions instead of hunting through filters. ### Data into Tallyfy These use cases are about getting information into Tallyfy without manual entry - from meeting notes, other systems, or documents you already have. **[Create tasks from meeting notes](/products/pro/integrations/byo-ai/use-cases/create-tasks-from-meeting-notes/)** - Paste in your meeting notes and let your AI pull out action items and create the right tasks. **[Launch processes with pre-filled data](/products/pro/integrations/byo-ai/use-cases/launch-processes-with-pre-filled-data/)** - Start a process and have your AI populate the kick-off form fields from data you provide. **[Insert data into form fields from other systems](/products/pro/integrations/byo-ai/use-cases/insert-data-into-form-fields-from-other-systems/)** - Push data from spreadsheets, emails, or other sources directly into running task form fields. ### Template building Building and improving templates is where Tallyfy's AI connection shines. These articles cover ways to create and refine templates through conversation rather than clicking through a form builder. **[Import a document as a template](/products/pro/integrations/byo-ai/use-cases/import-a-document-as-a-template/)** - Hand your AI an existing procedure document and have it turn the steps into a proper Tallyfy template. **[Build a template through conversation](/products/pro/integrations/byo-ai/use-cases/build-a-template-through-conversation/)** - Describe your process in plain language and have your AI construct the template step by step. **[Import forms into kick-off or step fields](/products/pro/integrations/byo-ai/use-cases/import-forms-into-kick-off-or-step-fields/)** - Take an existing form - PDF, Word, or just a list of questions - and convert it into properly typed form fields. **[Merge and combine templates](/products/pro/integrations/byo-ai/use-cases/merge-and-combine-templates/)** - Spot overlapping templates in your library and consolidate them into a single, cleaner process. **[Audit and improve your templates](/products/pro/integrations/byo-ai/use-cases/audit-and-improve-your-templates/)** - Get a plain-language review of any template - missing assignments, unclear steps, gaps in logic. ### Automation and advanced **[Set up automation rules in plain language](/products/pro/integrations/byo-ai/use-cases/set-up-automation-rules-in-plain-language/)** - Describe the "if this, then that" logic you want and have your AI configure the automation rules for you. **[Generate reports from process data](/products/pro/integrations/byo-ai/use-cases/generate-reports-from-process-data/)** - Ask questions about your process history and get structured answers - completion times, bottlenecks, patterns. --- Each article includes ready-to-use prompts for Claude, ChatGPT, Copilot, and Gemini. Copy, paste, and go - no prompt engineering required. ### Use cases - **[Audit and improve your templates](https://tallyfy.com/products/pro/integrations/byo-ai/use-cases/audit-and-improve-your-templates/)**: Tallyfy's AI can audit any process template for missing instructions, form fields, assignees, and deadlines. It fills gaps with sensible defaults so you can launch cleaner, more reliable workflows without hours of manual review. ## Find what's missing and fix it automatically Templates accumulate gaps over time - steps with no instructions, form fields nobody ever filled in, ownership that was never assigned. Your AI runs a health check on any Tallyfy template, tells you exactly what's missing, and fills in the gaps with sensible defaults so you can launch a cleaner, more reliable process. ### What you'll accomplish - Run a complete health check on any Tallyfy template - Identify missing descriptions, form fields, assignees, and deadlines - Let the AI fill in gaps automatically with sensible defaults - Audit multiple templates at once ### Try it now **What happens:** The AI uses `assess_template_health` for complete template data, then `get_template_steps` for step details. It calls `analyze_template_automations` to check automation rules and detect redundancies, and `suggest_automation_consolidation` for prioritized improvement suggestions. For fixes, it uses `edit_description_on_step`, `suggest_form_fields_for_step`, `add_form_field_to_step`, `suggest_step_deadline`, and `add_assignees_to_step`. ### How it works behind the scenes The audit runs in two phases. **Phase 1 - Analysis:** 1. `assess_template_health` - retrieves complete template data including metadata, steps, automations, and kickoff fields 2. `get_template_steps` - retrieves every step with its description, form fields, assignees, and deadline info 3. `analyze_template_automations` - checks for conflicts, redundancies, and orphaned rules with automatic redundancy detection 4. `suggest_automation_consolidation` - returns prioritized suggestions for consolidation (duplicates, conflicts, merge candidates) **Phase 2 - Fixes (if requested):** 5. `edit_description_on_step` - writes instructions for steps that have none 6. `suggest_form_fields_for_step` - recommends form fields based on step content 7. `add_form_field_to_step` - adds the suggested fields 8. `suggest_step_deadline` - recommends deadlines based on step type and complexity 9. `add_assignees_to_step` - assigns roles based on step content The AI decides which tools to call based on what it finds. If a template has full descriptions but no deadlines, it skips straight to `suggest_step_deadline`. If everything looks good, it says so rather than making unnecessary changes. ### What the health check covers A good Tallyfy template does more than list what needs to happen - it tells people how to do it, who's responsible, and when it needs to be done. The health check looks at six dimensions: **Step descriptions** - Are instructions clear and complete? A step called "Review contract" means different things to different people. The AI checks whether each step has enough context for someone unfamiliar with the process to complete it correctly. **Form fields** - Does each step collect the data it needs? Steps that gather information but have no form fields force people to document things outside Tallyfy, in emails or spreadsheets, where they're harder to track. The AI flags steps whose names or descriptions imply data collection but have no fields attached. **Assignments** - Is someone responsible for every step? Unassigned steps are the most common reason processes stall. They sit in limbo until someone notices and figures out who should own them. The AI checks every step and suggests an assignee based on the step's content and any patterns it sees elsewhere in the template. **Deadlines** - Do time-sensitive steps have due dates? Not every step needs a deadline, but steps like "Send contract" or "Submit application" usually do. The AI identifies steps that should have a deadline and suggests one based on the step type and typical process timelines. **Automation rules** - Are there conflicts, redundancies, or gaps? A template might have two automation rules that trigger on the same condition but take different actions, or a step that should trigger an action but doesn't. The AI reviews all automation rules and checks for logical consistency. **Step ordering** - Does the sequence make sense? Steps should flow in an order that reflects how work actually gets done. The AI looks for dependencies that aren't reflected in the ordering - for example, a step that requires information from a later step. ### Auditing multiple templates The most valuable audits often happen at the organization level, not the template level. You can ask broad questions across your entire Tallyfy account: - "Which of my templates are incomplete?" - "Find all steps across all templates that have no description" - "Which templates have zero automation rules?" - "Show me every unassigned step in all my templates" - "Which templates haven't been updated in over a year?" - "Find templates where more than half the steps have no instructions" For these requests, the AI uses `get_all_templates` to retrieve every template, then loops through each one calling `get_template_steps` and `assess_template_health`. It compiles the results into a summary you can act on - either by fixing issues across all templates at once, or by prioritizing the worst offenders first. This kind of organization-wide audit is especially useful when you're inheriting templates someone else built, onboarding a new team onto Tallyfy, or doing a periodic review of processes that haven't been touched in a while. Running it before you launch a process catches problems that would otherwise surface as confusion or delays once real work is in flight. ### When to run an audit A few situations where running this check pays off immediately: **Before launching a new process** - Templates often get built in a hurry, with placeholders and good intentions that never got filled in. A quick audit before launch catches empty steps and missing owners before they cause problems. **After inheriting templates from someone else** - When you take over a process that someone else built, you rarely know what's missing until something goes wrong. An audit gives you a complete picture of what's there and what's not. **When a process keeps breaking down** - If a process consistently gets stuck at the same step, or if people keep asking the same questions about what they're supposed to do, the root cause is usually a gap in the template itself - a missing description, an unassigned step, a form field that was never added. **Periodic reviews** - Processes change over time. Steps get added, roles change, deadlines that made sense two years ago no longer apply. A regular audit keeps templates aligned with how work actually gets done. **Before sharing templates with clients or partners** - If external people are going to run your Tallyfy processes, every step needs to be self-explanatory. An audit ensures nothing requires insider knowledge to complete. ### Tips for better results **Start with analysis before asking for fixes.** Saying "Audit first, then fix" gives you a chance to review what the AI found before it makes changes. You might agree with some suggestions and disagree with others. **Review suggestions before they're applied.** You can say "Show me what you'd change before changing it" and the AI will list every proposed edit. This is the right approach for templates that are actively in use, where unexpected changes could confuse people mid-process. **Be specific about what to fix.** If you only want descriptions added but don't want form fields touched, say so: "Only add descriptions, don't change form fields." The AI respects scope constraints. **For organization-wide audits, ask for a summary first.** Ask "Give me a summary of which templates need the most work" before diving into individual fixes. This helps you prioritize and avoid spending time on templates that are already in good shape. **Use the audit before launching a process.** It's much easier to fix gaps before a process is running than after. People who are partway through a process find changes disorienting, and mid-run edits to steps can create inconsistencies between active runs and the updated template. **Combine the audit with other improvements.** After fixing gaps, you might want to build automation rules for steps that currently require manual follow-up, or split a complex step into two clearer ones. The audit is a good starting point for a broader template improvement session. ### What good templates look like After running an audit and applying fixes, a well-formed Tallyfy template has a few consistent qualities. Every step has a description that tells someone unfamiliar with the process exactly what to do - not just a step name, but actual instructions. Steps that collect information have form fields that capture the right data in a structured way. Every step has an owner, whether that's a specific person, a role, or a group. Time-sensitive steps have deadlines. And automation rules are clean - no conflicts, no redundancies, and no obvious gaps where a rule should exist but doesn't. None of this requires hours of manual review. The AI does the analysis in seconds and applies fixes just as quickly. The result is a template that's ready to run reliably, with less confusion and fewer interruptions. ### Take it further - [Set up automation rules in plain language](/products/pro/integrations/byo-ai/use-cases/set-up-automation-rules-in-plain-language/) - [Build a template through conversation](/products/pro/integrations/byo-ai/use-cases/build-a-template-through-conversation/) - [Merge and combine templates](/products/pro/integrations/byo-ai/use-cases/merge-and-combine-templates/) - **[Build a template through conversation](https://tallyfy.com/products/pro/integrations/byo-ai/use-cases/build-a-template-through-conversation/)**: Describe your process in plain language to an AI assistant like Claude or ChatGPT. It'll create a Tallyfy template with steps, form fields, assignments, and deadlines through a back-and-forth conversation you can refine without touching a template builder. ## Describe your process - your AI builds it You know how your process works. You just don't want to click through template builders to set it up. Describe what happens step by step in plain language, and your AI creates the Tallyfy template for you - adding steps, form fields, assignments, and deadlines as you go. No clicking through menus. No hunting for the right settings panel. Just describe, refine, and you're done. ### What you'll accomplish - Build a complete Tallyfy template by describing your process in conversation - Add form fields, assignments, and deadlines through natural language - Iterate and refine the template through back-and-forth with your AI ### Try it now ### How it works behind the scenes Your AI processes your description and makes multiple tool calls in sequence to build the template from scratch. **Creating the template**: First, the AI calls the tool to create a new empty Tallyfy template, giving it a name based on what you described. This is the container everything else goes into. **Adding steps**: For each stage you described, the AI calls `add_step_to_template`. The AI adds steps in order - it reads your numbered list and preserves the sequence. If you described branching (like "if rejected, loop back to step 1"), it will note that and ask how you want to handle conditional logic before proceeding. **Writing step instructions**: The AI calls `edit_description_on_step` for each step to add clear instructions. These aren't just the step name - they're the actual guidance that will appear for whoever completes the task. The AI generates these from your description, expanding brief notes into actionable instructions. **Recommending form fields**: Before adding fields, the AI calls `suggest_form_fields_for_step`. This is where it reasons about what data each step actually needs to collect. A step described as "log the customer name, email, and complaint type" is straightforward. A step described more loosely - "the team documents their findings" - will prompt the AI to ask what specifically should be captured. **Adding form fields**: The AI calls `add_form_field_to_step` for each field. Field types are inferred from your description: - Lists of options ("product defect, billing issue, service problem") → dropdown field - Names, free-text descriptions → text field - Dates and deadlines → date picker - Numeric values → number field - Email addresses → email field - Yes/no decisions → checkbox **Setting assignments**: If you mentioned who handles each step - "the support team," "their direct manager," "the procurement team" - the AI calls `add_assignees_to_step` to assign the relevant group or role. It works with groups and job titles, not just individual users, so new team members automatically pick up the right tasks. **Suggesting deadlines**: For steps where timing matters, the AI calls `suggest_step_deadline` based on the complexity you described. It won't invent deadlines you didn't mention, but it will recommend reasonable ones if you ask. The whole build happens in one conversation. You describe, the AI builds, and you can see the results in your Tallyfy account as the tool calls complete. ### The iterative advantage This is where conversational template building really pays off. The first pass creates a working template - but the second and third exchanges refine it into something genuinely useful. After the initial build, you might say: - "Actually, add a checkbox on the first step for 'Customer acknowledged receipt of our response'" - "Make step 3 an approval step - it needs manager sign-off before moving forward" - "Add a priority field to step 1 - options should be urgent, high, normal, low" - "Move step 4 before step 3, the sequence is wrong" - "What form fields would you suggest for the investigation step?" - "Add a text area on the final step for 'Internal notes - visible to staff only'" Each instruction triggers the exact right tool calls. You're not learning which menu has which option - you're just saying what you want and watching it happen. The AI keeps the full context of your template in the conversation. "Make the third step an approval" works because the AI knows what the third step is. "Add a field similar to the one on step 2" works because it remembers what's already there. A few things the AI will ask rather than assume: - **Branching logic**: If you describe a step that should behave differently based on a previous answer (like "if rejected, go back to draft"), the AI will confirm the exact condition before setting it up - **Assignment ambiguity**: If you say "the manager approves it" but haven't specified which group or job title that maps to in Tallyfy, the AI asks before assigning - **Required vs. optional fields**: If it's not clear whether a field should block step completion or just be suggested, the AI will ask ### Tips for better results **Start with the big picture, then add detail.** Describe all your steps first, then refine each one. Trying to specify every field on step one before moving to step two makes the conversation harder to follow - for you and the AI. **Name the roles and groups that should be assigned, not specific people.** "The procurement team" or "direct manager" works better than "John" or "Sarah" - those role-based assignments work for everyone in your organization, not just current employees. **Mention step types explicitly when they matter.** "Make this an approval step" or "this should be an email step" tells the AI to use Tallyfy's specialized step types rather than a standard task. Approval steps in Tallyfy have built-in approve/reject logic - much better than a custom form field trying to replicate the same thing. **Ask the AI for suggestions.** If you're not sure what form fields make sense for a step, just ask: "What form fields would make sense on the investigation step?" The AI calls `suggest_form_fields_for_step` and gives you a list based on the step description. You pick what to keep. **Describe branching in plain language.** "If the complaint type is billing, skip the investigation step and go directly to resolution" is enough for the AI to understand the conditional. It will confirm the details before setting up the automation rule. **Reference your existing process documentation.** If you have a process map, a Word document describing the workflow, or even an email chain that explains how something works - paste the relevant section and ask the AI to build a Tallyfy template from it. It handles unstructured source material well. **Iterate freely.** Unlike a template builder UI where you'd click through to each element, the AI conversation keeps everything in context. Changing your mind about step order, field names, or assignments is just a sentence away. ### Take it further - [Import a document as a template](/products/pro/integrations/byo-ai/use-cases/import-a-document-as-a-template/) - [Set up automation rules in plain language](/products/pro/integrations/byo-ai/use-cases/set-up-automation-rules-in-plain-language/) - [Audit and improve your templates](/products/pro/integrations/byo-ai/use-cases/audit-and-improve-your-templates/) - **[Check process status across your team](https://tallyfy.com/products/pro/integrations/byo-ai/use-cases/check-process-status-across-your-team/)**: Ask your AI one question to scan all running Tallyfy processes and find overdue tasks with assignee names and delay times. Spot workflow bottlenecks in seconds instead of clicking through dashboards. ## Spot bottlenecks before they become problems Managers and team leads - this one's for you. Instead of clicking through a dozen open processes to figure out what's stuck, you can ask your AI to do the legwork: pull every running Tallyfy process, check which tasks are overdue, and tell you exactly who's responsible. One question replaces ten minutes of dashboard hunting. ### What you'll accomplish - See the status of all running processes in one summary - Identify stalled or overdue tasks and who owns them - Spot bottlenecks across your team's workflows before they turn into real problems ### Try it now What happens when you send one of these prompts: the AI calls `get_organization_runs` to fetch all your active Tallyfy processes, then `get_tasks_for_process` for each one to check task status and due dates. It cross-references that against `get_organization_users` to match task assignments to real names. For larger organizations with many processes, it may also use `search_for_processes` to narrow results before pulling the full details. You get back a readable summary - not raw API output, but an actual answer that tells you what's fine, what's at risk, and what needs your attention right now. ### How it works behind the scenes There's a small chain of API calls happening when your AI answers a process status question, and it helps to understand it so you know what to expect. **Step 1 - Get all active processes** The AI starts with `get_organization_runs`. This returns every process currently running in your Tallyfy organization - the name, which template it came from, when it was started, and its current state. Think of this as the index: it tells the AI what exists, but not the detail inside each one. **Step 2 - Pull task details for each process** Next, the AI calls `get_tasks_for_process` for each active process. This is where it gets the real signal: which tasks are complete, which are open, which are overdue, and who's assigned to each. If you have 20 running processes, the AI makes 20 calls here - it's doing the repetitive clicking you'd otherwise do yourself. **Step 3 - Cross-reference people and deadlines** With task data in hand, the AI compares due dates against today's date to calculate overdue status. It pulls `get_organization_users` to translate user IDs into actual names. The result is a list of bottlenecks with real context: not just "Task X is overdue" but "Task X in the Client Onboarding process for Acme Corp is 4 days overdue and assigned to Jamie." **For individual workloads** If you ask about a specific person - "How is Sarah's work looking?" - the AI can use `get_user_tasks` instead of scanning every process. This is faster and more focused when you already know who you want to check on. The whole chain runs in seconds. You're not waiting for a report to be generated or a dashboard to load - you're getting a real-time answer assembled from live Tallyfy data. ### Tips for better results The prompts above will get you started, but small tweaks to how you ask make a real difference in what you get back. **Filter by template** If you only care about one type of process, say so. "Show me the status of all Client Onboarding processes" or "Are any of the Employee Offboarding processes stalled?" keeps the response focused instead of giving you a wall of unrelated processes. **Ask about specific people** "How are Marcus's processes looking?" or "Which tasks does Priya own that are overdue?" pulls individual workload data using `get_user_tasks` and is much faster than scanning everything. Good for 1-on-1 check-ins or when someone's out and you need to reassign their work. **Request a specific format** If you need to share the results in a meeting or paste them into a Slack message, ask for a format upfront. "Give me a table with columns: process name, template, percentage complete, overdue task count, and how long it's been stuck" gets you something ready to share without editing. **Set a threshold** "Only flag tasks overdue by more than 3 days" cuts out the noise. Not every overdue task is a crisis - a task that's 6 hours past due is very different from one that's been stuck for a week. Setting thresholds helps you focus on things that actually need your attention. **Combine filters** You can stack these: "Show me all running HR onboarding processes where a task has been overdue for more than 5 days, and tell me who's assigned to the stuck task." The AI handles the logic of combining these conditions - you don't need to think about which API call does what. **Ask for a trend, not just a snapshot** "Have the number of overdue tasks gone up compared to last week?" or "Which processes have been running the longest without completing?" gets at systemic issues rather than just today's status. This is useful for identifying templates that need to be redesigned, not just processes that need a nudge. ### What good output looks like A well-formed answer to a process status question from your AI should tell you: - How many processes are currently active - Which ones have overdue tasks (with the process name and template it came from) - How many tasks are overdue in each, and by how many days - Who owns the stuck tasks - Any processes that have been active for an unusually long time with little progress You might get something like: > "You have 14 active processes. 3 have overdue tasks: > - Client Onboarding - Riverbank Financial (template: Client Onboarding): 2 tasks overdue, assigned to Sam (3 days) and Alex (1 day) > - Employee Offboarding - Jordan Lee (template: HR Offboarding): 1 task overdue, assigned to HR Team (5 days) > - Vendor Review - Q1 Suppliers (template: Vendor Review): 1 task overdue, assigned to Finance (7 days) > > The Finance-assigned task in Vendor Review has been stuck the longest. Want me to send a reminder to any of these assignees?" That last offer - "want me to send a reminder?" - is a good example of how this tool can chain into the next action. You can say yes and have the AI draft a message, or ask it to pull up more detail on one of the stuck processes. ### When this is most useful **Monday morning standup prep** Before your team call, ask for a full process status sweep. You walk in knowing exactly what's stuck, who to ask about it, and where to focus the conversation. No more "I'll have to check and get back to you." **End-of-week review** "What processes started this week? Which ones made the most progress? Are any that started Monday still not past the first task?" This gives you a real view of your team's throughput without pulling a report manually. **Before a client call** "Show me the status of the Client Onboarding process for Meridian Corp." One question gives you everything you need to update the client: what's done, what's in progress, what's next, and whether anything is behind. **When someone's out** "What open tasks does Jamie have right now?" pulls a full list so you can reassign or flag anything time-sensitive. Much faster than asking around or checking each process manually. **Spotting systemic problems** If the same task keeps appearing in your overdue list week after week across multiple process instances, that's a sign the template needs fixing - not just the individual process. Asking "which task step shows up most often in overdue lists?" can surface those patterns. ### Take it further Once you know what's stuck, you can act on it without leaving your AI conversation. Some things you can do next: - Ask the AI to send a task reminder to the person who's overdue - Have it reassign a task to someone else - Ask it to update the due date on a specific task - Request a written summary you can paste into a team update Tallyfy's MCP integration means your AI isn't just reading data - it can take actions too. Spotting a bottleneck and fixing it can happen in the same conversation. - [Get a daily briefing of your tasks](/products/pro/integrations/byo-ai/use-cases/get-a-daily-briefing-of-your-tasks/) - [Generate reports from process data](/products/pro/integrations/byo-ai/use-cases/generate-reports-from-process-data/) - [Find anything across your workflows](/products/pro/integrations/byo-ai/use-cases/find-anything-across-your-workflows/) - **[Connect your AI to Tallyfy](https://tallyfy.com/products/pro/integrations/byo-ai/use-cases/connect-your-ai-to-tallyfy/)**: Connect any major AI platform like Claude, ChatGPT, Copilot, or Gemini to Tallyfy in under five minutes. Add one MCP server URL, authorize your account, and your AI can read and act on tasks, processes, and templates through natural conversation. ## One-time setup for any AI platform You only need to do this once. Add Tallyfy's MCP server URL to your AI platform, authorize with your Tallyfy account, and you're connected - your AI can then read and act on your workflows through natural conversation. ### What you'll accomplish - Connect your AI to Tallyfy in under 5 minutes - Verify the connection works with a simple test prompt - Understand where credentials are stored and what permissions you're granting ### Try it now ### How it works behind the scenes Your AI platform connects to Tallyfy's MCP server using OAuth 2.1 with PKCE[^1]. You sign in once with your Tallyfy credentials and authorize access - that's it. Your AI platform stores the resulting token securely (in the OS keychain for desktop apps, in a platform vault for web apps), so you won't need to authorize again unless you revoke access. From there, the MCP server exposes Tallyfy actions as named tools your AI can call - 115 tools across 15 categories covering tasks, processes, templates, form fields, kickoff fields, automations, users, and more. ### What permissions are granted When you authorize, you grant the following OAuth scopes[^2]: | Scope | What it covers | |---|---| | `mcp.tasks.read` | View tasks and assignments | | `mcp.tasks.write` | Create, update, and complete tasks | | `mcp.processes.read` | View workflow runs | | `mcp.processes.write` | Launch, update, and archive processes | | `mcp.templates.read` | View templates and steps | | `mcp.templates.write` | Edit templates, steps, and automations | | `mcp.forms.read` | View form fields | | `mcp.forms.write` | Add and modify form fields | | `mcp.users.read` | View organization members and guests | | `mcp.users.write` | Invite and manage users | | `mcp.automation.read` | View automation rules | | `mcp.automation.write` | Create and modify automations | You can revoke access at any time. In Tallyfy, go to your account settings and remove the authorized application. In your AI platform, disconnect the connector or integration from its settings panel. ### Tips for better results - **Start with read-only questions** before trying write operations. Get a feel for what your AI can see before asking it to make changes. - **Be specific** - name the template, process, or person explicitly. "What tasks are assigned to Sarah on the Client Onboarding process?" gets a better result than "what's Sarah doing?". - **Your AI will ask for confirmation** before making changes to Tallyfy data. That's intentional - review the proposed action before approving it. ### Take it further Once you're connected, here are some things worth trying next: - [Get a daily briefing of your tasks](/products/pro/integrations/byo-ai/use-cases/get-a-daily-briefing-of-your-tasks/) - [Find anything across your workflows](/products/pro/integrations/byo-ai/use-cases/find-anything-across-your-workflows/) - [Launch processes with pre-filled data](/products/pro/integrations/byo-ai/use-cases/launch-processes-with-pre-filled-data/) [^1]: Proof Key for Code Exchange - prevents authorization code interception attacks during the OAuth flow [^2]: OAuth scopes define exactly what data the AI can access - nothing outside these scopes is visible - **[Create tasks from meeting notes](https://tallyfy.com/products/pro/integrations/byo-ai/use-cases/create-tasks-from-meeting-notes/)**: Paste messy meeting notes into any AI assistant connected to Tallyfy. It automatically parses every action item into assigned, deadline-tracked tasks by matching names to your member list and extracting due dates from natural language. ## Turn action items into tracked tasks instantly Meetings generate action items. Most of them get lost. You leave a standup with five things to follow up on, someone types them into a chat message, and by Thursday no one remembers who said they'd handle what. Paste your meeting notes into your AI and it creates Tallyfy tasks for every action item - with the right assignees and deadlines - in one go. No reformatting required. Messy notes work fine. The AI handles the parsing. ### What you'll accomplish - Convert raw meeting notes into structured Tallyfy tasks - Automatically assign tasks to the right team members - Set deadlines based on what was discussed in the meeting ### Try it now ### How it works behind the scenes There are two tool calls involved, and they happen in sequence. First, the AI calls `get_organization_users`. This pulls the full member list for your Tallyfy organization - names, email addresses, user IDs. The AI then reads through your meeting notes and tries to match each name it finds against that list. Sarah becomes a specific user ID. Mike becomes another. That's what makes assignment work - without it, the AI would be guessing. Then, for each distinct action item, the AI calls `create_task_from_text`. You pass the natural language description - something like "Sarah to finish the Q3 report by Friday" - and Tallyfy's MCP server does the extraction. It pulls out the task title, reads the assignee field, and parses the deadline. The task shows up in Tallyfy assigned to the right person with the due date set. A few things worth knowing about how the name matching works. If you use a first name that exists in your organization exactly once, the match is automatic. If you have two people named Sarah, the AI will ask which one. If a name doesn't appear in your Tallyfy member list at all - say, someone who hasn't been invited yet - the AI will flag it and ask how you want to handle it. It won't silently skip the task or assign it to the wrong person. The deadline parsing handles relative dates reasonably well. "By Friday" becomes the upcoming Friday's date. "This week" typically becomes end of the working week. "Next Tuesday" looks past the current week to the following one. If you want precision, use explicit dates - "March 28" is better than "end of the month" for anything time-sensitive. ### Tips for better results **Use full names that match your Tallyfy member list.** First names work when they're unique in your organization, but "Sarah Chen" is safer than "Sarah" if you have multiple Sarahs. Your AI will ask for clarification if there's ambiguity, but saving that extra step is worth it. **Mention specific dates rather than relative ones.** "By March 28" works more reliably than "next week" or "soon." If your notes say "by end of Q1," add a date clarification before submitting the prompt. **Paste the notes exactly as they are.** Don't reformat them. Bullet points, run-on sentences, parenthetical comments - the AI handles all of it. Cleaning up your notes before pasting is unnecessary work. **Add context if tasks need it.** "Mike to review the vendor contract" creates a task. "Mike to review the vendor contract - focus on the indemnification clauses, flagged by legal" creates a more useful one with actual context in the description. More information in the notes means more information in the task. **If you have a meeting transcript, paste the relevant section.** You don't need to pre-extract action items. Many AIs can read a full transcript and identify which lines are action items versus discussion. Try: "Here's our meeting transcript - find all the action items and create Tallyfy tasks for each one." **Include the meeting name or project name in your prompt.** "Create Tallyfy tasks for each action item from our Q2 planning meeting" gives the AI useful context for naming and organizing the tasks. Some AIs will include the meeting name in the task description automatically. **Review before your team acts on the tasks.** The AI is reading natural language, which means occasional misreads. "Sarah mentioned she'd look at the report" might get parsed as a task even if Sarah was just saying she'd glance at it - not commit to delivering it. A quick scan of the created tasks before you log off takes thirty seconds and catches those edge cases. ### What to do when names don't match The most common friction point is name matching. Your meeting notes say "Jordan" but Jordan's Tallyfy account is under "Jordan M." or a work email with a different display name. When this happens, the AI will stop and ask. It might say: "I found 'Lisa' in your notes but couldn't match her to a Tallyfy user. Do you want me to skip this task, assign it to you, or is her account under a different name?" A few ways to get ahead of this: - Before your first run, ask your AI: "List all the members in my Tallyfy organization" - this shows you exactly what names and display names are in the system. - If your team uses nicknames or shortened names in meetings, keep a simple note of the mapping: "Dan = Daniel Thompson in Tallyfy." - For recurring meetings with a fixed set of attendees, you can front-load the names in your prompt: "The meeting attendees in Tallyfy are: Sarah Chen, Mike Okafor, Lisa Patel. Here are the action items..." ### Take it further Once you're comfortable turning meeting notes into tasks, a few natural extensions open up in Tallyfy: - [Launch processes with pre-filled data](/products/pro/integrations/byo-ai/use-cases/launch-processes-with-pre-filled-data/) - if a meeting kicks off a repeatable workflow (like a new client onboarding), launch the full process instead of individual tasks - [Insert data into form fields from other systems](/products/pro/integrations/byo-ai/use-cases/insert-data-into-form-fields-from-other-systems/) - push data from meeting notes or other sources into form fields on tasks already in progress - [Get a daily briefing of your tasks](/products/pro/integrations/byo-ai/use-cases/get-a-daily-briefing-of-your-tasks/) - the morning after a meeting, ask your AI to show you all the tasks created yesterday and which ones are most urgent - **[Find anything across your workflows](https://tallyfy.com/products/pro/integrations/byo-ai/use-cases/find-anything-across-your-workflows/)**: Tallyfy's AI-powered search lets you type plain-language questions to find tasks, processes, and templates across your organization in seconds. No need to click through multiple screens or set up filters manually. ## Search Tallyfy the way you think Instead of clicking through screens and setting up filters, just describe what you're looking for. Your AI searches across tasks, processes, and templates simultaneously and brings back exactly what matches - no hunting required. ### What you'll accomplish - Search across tasks, processes, and templates with one natural language question - Find items by client name, keyword, template purpose, or any other criteria - Skip the click-through-multiple-screens workflow entirely ### Try it now Connect your AI to Tallyfy first, then try any of these prompts directly. ### What happens when you ask When you type a search prompt, your AI figures out what kind of thing you're looking for and calls the right tool - or combination of tools - to find it. - **`search_for_tasks`** - keyword search across all tasks in your organization. Good for finding specific action items, task names, or anything assigned to someone. - **`search_for_processes`** - keyword search across all running processes. Useful when you want to see every active workflow tied to a client, project, or topic. - **`search_for_templates`** - keyword search across your template library. Helpful when you know roughly what a template does but can't remember its name. - **`get_all_templates`** - retrieves your full template list. The AI falls back to this when your search term is broad or when it wants to browse before narrowing down. For a prompt like "find everything related to Acme Corp", your AI will likely run `search_for_processes` and `search_for_tasks` in parallel. For "which template handles vendor onboarding", it will call `search_for_templates` and possibly `get_all_templates` if the keyword search doesn't surface a clear match. You don't need to think about which tool to use. That's the point. ### How it works behind the scenes Every search goes through Tallyfy's MCP server at `https://mcp.tallyfy.com`. The AI sends your natural language question, picks the appropriate tool or tools, and the server queries your organization's data using your authenticated credentials. The flow: 1. You type a question in plain language 2. Your AI parses the intent - are you looking for tasks, processes, templates, or some combination? 3. It calls the relevant search tools with the right keyword parameters 4. The MCP server queries Tallyfy and returns structured results 5. Your AI formats those results into a readable response Results come back with context - not just names, but status, assignees, associated templates, and other details that help you figure out what to do next. If you ask a follow-up question ("who's the owner of that process?"), the AI can call `get_process` or `get_tasks_for_process` to drill deeper. One search prompt can pull together information that would otherwise require opening three or four different Tallyfy screens. That's the practical win here. ### Tips for better results **Be specific about the subject.** "Find the onboarding process for Jane Smith" returns more precise results than "find onboarding". The more context you give, the less the AI has to guess. **Say what you want returned.** "Show me the template name, status, and who owns it" shapes the output so you're not wading through unnecessary detail. **Combine search types in one prompt.** "Find all tasks and processes related to our Q2 audit" works fine - your AI will run both `search_for_tasks` and `search_for_processes` at once rather than making you ask twice. **Use purpose or intent, not just names.** You don't need to know the exact template name. "Which template do we use when a new contractor starts?" works just as well as knowing the template is called "Contractor Onboarding v3". **Add context from other systems.** You can paste a client name from your CRM, a project code from a spreadsheet, or a subject line from an email and ask Tallyfy to find anything matching it. The AI handles the translation between how you describe things and how they're named in Tallyfy. **Narrow down after a broad search.** Start with "show me all processes tagged with 'legal'" and then follow up with "which of those are still active?" rather than trying to construct the perfect query upfront. Iterating is faster than front-loading every condition. ### What this looks like in practice Say you're jumping into a client meeting in 10 minutes and need to get up to speed quickly. Instead of opening the tracker, filtering by client name, checking the tasks view separately, and then looking up which template is in use - you just ask: ```text What's the current status of everything we have running for Meridian Financial? Show me active processes, any overdue tasks, and which templates are involved. ``` Your AI calls `search_for_processes` and `search_for_tasks` simultaneously, combines the results, and gives you a summary. Thirty seconds instead of five minutes of clicking. Or maybe you're cleaning up your template library and suspect you have duplicates. Try: ```text Do we have more than one template for client intake or onboarding? List all templates with "intake" or "onboarding" in the name or description. ``` The AI calls `get_all_templates` or `search_for_templates` with those keywords and returns a list you can review. You spot three variations of the same process that have accumulated over time - problem found, in a single prompt. Another common scenario: a colleague is out sick and you need to figure out what they were working on. Rather than requesting admin access to their task queue: ```text Find all open tasks assigned to sarah@company.com across all active processes ``` `search_for_tasks` handles this. You get a list of everything in Sarah's queue, the processes they belong to, and which ones look urgent based on deadlines. These aren't contrived examples. They're the kinds of lookups people do manually every day - and each one takes a few clicks and some mental overhead that adds up. Having a single place to ask removes that friction entirely. ### Take it further - [Check process status across your team](/products/pro/integrations/byo-ai/use-cases/check-process-status-across-your-team/) - [Get a daily briefing of your tasks](/products/pro/integrations/byo-ai/use-cases/get-a-daily-briefing-of-your-tasks/) - [Generate reports from process data](/products/pro/integrations/byo-ai/use-cases/generate-reports-from-process-data/) - **[Generate reports from process data](https://tallyfy.com/products/pro/integrations/byo-ai/use-cases/generate-reports-from-process-data/)**: Tallyfy's AI integration lets you generate instant reports on process data by asking questions in natural language. Get completion counts, timing analysis, bottleneck identification, and workload breakdowns without exporting spreadsheets. ## Get answers from your process data instantly Need to know how many onboarding processes completed this month? Which steps take the longest? Where work gets stuck? Ask your AI. It pulls the data directly from Tallyfy and gives you a formatted report - no spreadsheet exports, no dashboard setup, no waiting. ### What you'll accomplish - Generate ad-hoc reports from Tallyfy process data through conversation - Get completion counts, timing analysis, and bottleneck identification - Produce formatted summaries without exporting data or building reports manually ### Try it now **What happens:** The AI chains multiple tool calls - `get_all_templates` to find the right template, `get_organization_runs` to retrieve process data filtered by template and status, `get_tasks_for_process` for each process to analyze individual task timing and completion, and `get_organization_users` to attribute work to real names. It then calculates the metrics you asked for and assembles everything into a formatted report. ### How it works behind the scenes Report generation typically chains four to six tool calls, happening in sequence without you needing to manage any of it. **Step 1 - Identify the template** The AI starts with `get_all_templates` or `search_for_templates` to find the template you're asking about. If you say "Client Onboarding", it matches that to the right template in your Tallyfy organization and gets its ID. This ID is what everything else uses to filter data correctly. **Step 2 - Retrieve the processes** Next, `get_organization_runs` fetches all processes that match your criteria - filtered by template, status (completed, active, overdue), and date range. If you asked for "this month", the AI applies that filter here. The result is a list of process instances with high-level metadata: when they started, when they finished (if completed), and their current state. **Step 3 - Pull task-level detail** This is where the depth comes from. The AI calls `get_tasks_for_process` for each process to retrieve the tasks inside it - their completion times, who was assigned, whether they were overdue, and any form field data. For a report on 20 completed processes, this means 20 separate calls running in sequence. It's doing the repetitive clicking you'd otherwise do yourself. **Step 4 - Map users to names** Task data comes back with user IDs. The AI calls `get_organization_users` to translate those IDs into actual names - so the report says "Jamie handled 8 tickets" instead of "user_id_4892 handled 8 tickets". **Step 5 - Optional grouping** If you asked for breakdowns by tag or category, `get_tags` groups processes accordingly before the final calculations. **Step 6 - Assemble the report** With all the data in hand, the AI calculates what you asked for - counts, averages, durations, rankings - and formats it according to your instructions. No raw API output, just the answer. ### Types of reports you can ask for The prompts above are a starting point. Here are the most common report types and how to ask for them. **Completion reports** "How many [template] processes completed this month/quarter/year?" This is the simplest report type - a count with optional breakdowns. You can add conditions: "How many completed on time?" or "How many completed in under a week?" **Timing analysis** "What's the average time to complete [template]? Which steps take the longest?" This pulls duration data from completed processes, calculates averages across all steps, and ranks them. Useful for spotting where time accumulates in a process. **Bottleneck identification** "Where do processes get stuck? Which steps have the most overdue tasks?" This looks at task-level overdue data across active processes and surfaces the steps that consistently cause delays. Good for identifying whether you have a template problem (poorly designed step) or a capacity problem (step consistently assigned to one person who's overloaded). **Team workload** "Who's handling the most processes? Who has the most overdue tasks?" Attribution reports map tasks back to specific people and show workload distribution. Useful before a 1-on-1, or when someone's out and you need to redistribute their queue. **Comparison reports** "Compare completion times for Client Onboarding this quarter versus last quarter." The AI pulls data from both periods and presents a side-by-side comparison. You can add more dimensions: "Break it down by which team ran the process" or "Show me whether it improved after we changed the template in February." **Status snapshots** "Give me a dashboard-style summary of all running processes right now." This is the real-time overview - counts by template, completion percentages, overdue counts, upcoming deadlines. Good for a Monday morning check-in or a weekly team update. ### Multi-step analysis The real value comes from chaining questions. Each one builds on the previous, and the AI keeps context across the whole conversation. A typical session might look like this: 1. "Show me all Client Onboarding processes from Q1" - establishes the data set 2. "Which ones took more than three weeks?" - filters to the slow ones 3. "What step caused the delay in each of those?" - finds the common bottleneck 4. "Add a comment to each of those processes noting the bottleneck for review" - takes action on the finding 5. "Write me a summary I can paste into our team Slack channel" - formats the output for sharing None of that requires switching tools, exporting data, or building anything. It happens in a single Tallyfy-connected conversation. You can also go the other direction - start specific and zoom out. "Show me the Smith Corp onboarding process" leads naturally to "Is this typical or is it slower than average?" which leads to "What's the average completion time across all onboarding processes?" ### What good report output looks like A well-formed report from your AI doesn't look like raw API output. It looks like something a person wrote, structured for the specific question you asked. For a completion and timing report, you might get: > "You completed 23 Client Onboarding processes in March. Average time from launch to completion was 9.2 days. The slowest step was 'Legal review' (average 3.1 days), followed by 'IT setup' (average 2.4 days). 4 processes took more than 14 days - all 4 had a delay at the Legal review step." For a status snapshot: > "Currently active processes: 31 total across 6 templates. 8 have at least one overdue task. The most affected template is Vendor Onboarding (5 of 9 active runs have overdue tasks). The oldest overdue task is 11 days past due, assigned to the Procurement team." That last detail - identifying the specific bottleneck and who owns it - is what makes this more useful than a dashboard. A dashboard shows you the number. Your AI tells you what it means and who to talk to. ### Tips for better results **Specify time ranges explicitly.** "This month" is good. "Since January 1st" is better when you want precision. "Last 30 days" works well for rolling windows. If you don't specify, the AI will often ask - but giving it upfront saves a round trip. **Name the template exactly as it appears in Tallyfy.** If the template is called "Client Onboarding v2", use that name. If you're not sure, ask: "What templates do we have for onboarding?" and pick from the list. **Ask for a specific format.** "Markdown table", "bullet points", "numbered list by total processes", "sorted by average duration" - the more specific you are about format, the less editing you need to do before sharing. **For comparisons, be explicit about what you're comparing.** "Compare Q1 and Q2" is clear. "Compare this year to last year, broken down by template" is even better because it tells the AI exactly what dimensions to split on. **Start broad, then drill down.** "Show me all processes" followed by "drill into the ones that took the longest" is usually faster than constructing a complex filtered query upfront. You can narrow down once you see what the data looks like. **If you need exact numbers, ask the AI to count rather than estimate.** For precision reporting - headcounts, completion rates, SLA compliance - explicitly ask the AI to count each item rather than give you a rough figure. It will be more careful about exactness when you make that expectation clear. **Combine with actions.** Once you have your report, you can act on it in the same conversation. "Send a reminder to everyone with an overdue task in those processes" or "Flag the three slowest processes for review" - Tallyfy's MCP integration means your AI can read and write, not just read. ### When this is most useful **Weekly team reviews.** Instead of manually building a status report before every meeting, ask your AI to generate it. Five seconds instead of thirty minutes. **End-of-quarter rollups.** Completion counts, average durations, team performance breakdowns - all available in one conversation without touching a spreadsheet. **Identifying template problems.** If the same step keeps showing up as the bottleneck across dozens of process instances, that's a template problem, not a people problem. Reporting at scale makes this pattern visible. **Client updates.** "Show me the current status of the Riverbank Financial onboarding process" gives you everything you need for a client call - what's done, what's in progress, what's next, and whether anything is behind. **Capacity planning.** "Who has the most active tasks right now?" or "Which team member is involved in the most running processes?" helps you spot overload before someone drops the ball. ### Take it further - [Check process status across your team](/products/pro/integrations/byo-ai/use-cases/check-process-status-across-your-team/) - [Find anything across your workflows](/products/pro/integrations/byo-ai/use-cases/find-anything-across-your-workflows/) - [Audit and improve your templates](/products/pro/integrations/byo-ai/use-cases/audit-and-improve-your-templates/) - **[Get a daily briefing of your tasks](https://tallyfy.com/products/pro/integrations/byo-ai/use-cases/get-a-daily-briefing-of-your-tasks/)**: Tallyfy's AI integration lets you replace manual task scanning each morning with a single prompt. It pulls your live task list and sorts it into overdue, due-today, and upcoming categories so you can start your day with a clear action plan. ## Your morning standup - powered by AI Instead of scrolling through your task list every morning trying to piece together what's urgent, just ask your AI. In one prompt, you get a prioritized view of everything assigned to you in Tallyfy: overdue items at the top, what's due today in the middle, and what's coming up this week so you can plan ahead. ### What you'll accomplish - Get a prioritized summary of all your Tallyfy tasks in one prompt - Identify overdue and urgent items instantly so nothing slips through - Start your day with a clear action plan instead of a wall of undifferentiated tasks ### Try it now ### How it works behind the scenes The core of this use case is a single tool call: `get_my_tasks`. When you send your morning briefing prompt, your AI immediately reaches out to Tallyfy, authenticates as you, and pulls back everything currently assigned to you: task names, deadlines, the process each task belongs to, and its current status. From there, the AI does the sorting. It reads each task's due date, compares it to today's date, and slots each task into a category: - **Overdue** - deadline has passed, not yet completed - **Due today** - deadline is today - **Due this week** - deadline is within the next seven days - **No deadline** - tasks with no due date set The AI then presents these groups in order of urgency, with overdue at the top. Most AIs will also calculate how many days overdue something is, which helps you triage quickly. A task that's one day overdue is different from one that's been sitting for two weeks. If you ask for team-wide tasks rather than just your own, the AI may also call `search_for_tasks` to pull in tasks assigned to others on your team. This is useful if you're a manager doing a morning check-in across your whole team rather than just your personal work queue. The AI reads live data from Tallyfy, not a cached snapshot. If someone completed a task five minutes ago, it won't show up in your overdue list. The briefing is always current. ### Tips for better results **Ask for specific time frames.** "What's due before Friday?" or "Show me anything due in the next 48 hours" gives you a tighter, more actionable list than a full week view when you're in crunch mode. **Request a format.** Adding "give me a markdown table" or "bullet points only, no extra commentary" shapes the output to match how you want to read it. If you're pasting the briefing into a Slack message or a daily note, a specific format saves you editing time. **Add context fields.** "Include the process name for each task" tells the AI to pull in the parent workflow for every item. This is useful when you're juggling multiple projects - knowing a task belongs to "Q2 Onboarding" vs "Website Refresh" changes how you prioritize. **Ask about blockers.** "Which of my overdue tasks might be blocked by someone else?" prompts the AI to look at task dependencies and assignee information in Tallyfy, surfacing items where you might need to follow up with a colleague rather than just act yourself. **Make it a habit.** The same prompt every morning means the AI builds familiarity with your typical task patterns. Some AIs will start to notice things like "you usually have three tasks due on Wednesdays" and surface that kind of context unprompted after a few days of consistent use. **Ask for a count.** "How many tasks do I have in each category?" is a fast gut-check. Seven overdue tasks is a different kind of morning than zero. ### Sample briefing output Here's the kind of response you can expect. The exact format varies by AI, but the content structure is consistent: That's nine tasks you'd otherwise have to manually scan for, now organized and prioritized in about three seconds. The overdue items are obvious, you know exactly what you need to finish today before logging off, and you have a clear view of what's coming up so you can block time in advance. ### Take it further Once you're comfortable with the daily briefing, a few natural next steps open up in Tallyfy: - [Check process status across your team](/products/pro/integrations/byo-ai/use-cases/check-process-status-across-your-team/) - zoom out from your personal task list to see how whole workflows are progressing - [Find anything across your workflows](/products/pro/integrations/byo-ai/use-cases/find-anything-across-your-workflows/) - when the morning briefing surfaces something you need to dig into, use search to pull up the full context - [Create tasks from meeting notes](/products/pro/integrations/byo-ai/use-cases/create-tasks-from-meeting-notes/) - turn action items from your morning standup directly into Tallyfy tasks without switching apps - **[Import a document as a template](https://tallyfy.com/products/pro/integrations/byo-ai/use-cases/import-a-document-as-a-template/)**: Paste any messy SOP, checklist, or process document into your AI and it'll build a clean Tallyfy template with steps, form fields, and role assignments. No cleanup or reformatting needed. ## Turn any document into a working workflow Got a messy SOP sitting in a Word doc? A checklist buried in a PDF? Paste the text into your AI and it builds a clean Tallyfy template - complete with steps, form fields, assignments, and descriptions - from whatever you give it. No cleanup required. The AI reads the mess and figures out what goes where. ### What you'll accomplish - Convert disorganized process documents into structured Tallyfy templates - Extract steps, form fields, and role assignments from messy source text - Skip the manual template-building process entirely ### Try it now ### How it works behind the scenes The AI works through your document in a logical sequence - and understanding each step helps you write better prompts. **Step 1: Check for duplicates** Before creating anything, the AI calls `get_all_templates` to scan your existing Tallyfy templates. If something called "Employee Onboarding" already exists, it'll flag that and ask whether to update the existing template or create a new one. No accidental duplicates. **Step 2: Parse the document** The AI reads your text looking for natural boundaries - paragraph breaks, numbered items, phrases like "then," "next," or "after that." Each distinct phase of your process becomes a candidate step. With the example document above, the AI identifies six steps even though the text isn't formatted as a list: the HR paperwork phase, the IT setup phase, the orientation meeting, the buddy assignment, the 30-day review, and the 90-day close-out. **Step 3: Create the template and add steps** The AI creates the template in Tallyfy and calls `add_step_to_template` for each identified step. Then it calls `edit_description_on_step` for each one, writing clear instructions drawn from your source text. "HR should collect all paperwork (tax forms, ID copy, emergency contacts, bank details for payroll)" becomes a proper step description - specific, actionable, and stripped of the vague phrasing from the original doc. **Step 4: Suggest and add form fields** This is where the AI earns its keep. For each step, it calls `suggest_form_fields_for_step` to analyze what data needs to be captured. The IT setup step mentions needing to know "what department and what software" - that becomes a department dropdown and a multi-line text field for software requirements. The orientation step says "should document the goals somewhere" - that becomes a text field for first-week goals. Then `add_form_field_to_step` adds each suggested field to the right step. **Step 5: Assign roles** The AI reads role references in your document - "HR should," "IT needs to," "Manager does" - and calls `add_assignees_to_step` to set assignments. If your Tallyfy account has job titles or groups matching those roles, the AI uses those. If the names in the document don't match anything in your organization, it'll ask before assigning. ### What the AI does with messy formatting Disorganized documents aren't a problem. The AI handles all of these without you needing to clean anything up first: **Prose paragraphs**: Most old SOPs aren't bulleted lists - they're paragraphs of instructions. The AI reads them the same way a human would, picking out discrete actions and responsibilities. **Mixed formats**: Some sections might be bulleted, others numbered, others just paragraphs. The AI handles inconsistency fine. **Implied information**: Phrases like "collect all paperwork" imply a checklist even if one isn't provided. The AI picks up on these and suggests appropriate form fields. **Vague assignees**: "Someone from the team" for the buddy role is ambiguous. The AI will note the ambiguity and either ask you to clarify or suggest a group assignment so any team member can take it. **Outdated instructions**: Your 2019 SOP might reference tools that no longer exist or processes that have changed. The AI builds the template from what's written - it won't silently update outdated content, but it won't refuse to work with it either. You can ask it to modernize specific steps if you want. **Missing details**: If a step in your document is thin on specifics, the AI writes what it can from context and may flag that the description could use more detail. It doesn't fabricate instructions that aren't in your source. ### Tips for better results **Paste the full document text, not a summary.** The AI works better with more context. If your Word doc is ten pages, paste all ten pages. Summaries lose the specific details that make form fields and descriptions useful. **Mention the step types you want.** If some steps should be approvals rather than standard tasks - say, the 90-day review needs sign-off from HR leadership - include that in your prompt: "Make the 90-day review step an approval step." **Call out parallel steps.** If some steps should run at the same time rather than sequentially, say so: "The IT setup and paperwork collection happen simultaneously - they shouldn't be blocked on each other." Tallyfy supports parallel steps and the AI will configure that if you ask. **Include related forms or checklists.** If your document references a separate checklist (a new hire paperwork checklist, a software access request form), include that text too. The AI uses it to build more accurate form fields. **Ask the AI to list what it found before building.** If you're not sure your document is structured clearly enough, add "Before building the template, list the steps you identified and ask me to confirm" to your prompt. You get a preview and a chance to correct any misreadings before anything is created in Tallyfy. **Specify your role names.** If your document says "Manager" but your Tallyfy account uses a job title called "Department Head," mention that: "When the document says Manager, use the 'Department Head' job title in Tallyfy." This avoids a round of clarification questions mid-build. ### Take it further - [Build a template through conversation](/products/pro/integrations/byo-ai/use-cases/build-a-template-through-conversation/) - if you don't have a source document, build the template interactively from scratch - [Import forms into kick-off or step fields](/products/pro/integrations/byo-ai/use-cases/import-forms-into-kick-off-or-step-fields/) - focus specifically on moving existing form data into Tallyfy fields - [Audit and improve your templates](/products/pro/integrations/byo-ai/use-cases/audit-and-improve-your-templates/) - once your template is built, use AI to review it for gaps and improvements - **[Import forms into kick-off or step fields](https://tallyfy.com/products/pro/integrations/byo-ai/use-cases/import-forms-into-kick-off-or-step-fields/)**: Paste field names and types from any PDF, Google Form, or spreadsheet into your AI assistant. It automatically creates matching form fields on your template's kick-off form or specific step. ## Recreate any form inside Tallyfy Have a PDF form, a Google Form, or a spreadsheet with column headers you want to turn into Tallyfy form fields? Paste the field list into your AI and tell it where to put them - kick-off form or a specific step. The AI creates each field with the right type, matching text fields to text, dropdowns to dropdowns, dates to dates. ### What you'll accomplish - Convert external form fields into Tallyfy kick-off or step form fields - Automatically match field types (text, dropdown, date, checkbox, etc.) - Skip manual field-by-field creation in the template builder ### Try it now What happens when you send one of these prompts: the AI calls `get_template` or `search_for_templates` to find the template, then `get_kickoff_fields` or `get_template_steps` to see what fields already exist. Then it calls `add_form_field_to_step` for each field in your list, matching your described type to the right Tallyfy field type. For any dropdowns, it calls `update_dropdown_options` to set the choices. Required fields get flagged via `update_form_field`. ### How it works behind the scenes There's a short chain of tool calls your AI runs every time you paste a field list and ask it to recreate them in Tallyfy. **Step 1 - Find the target template** The AI calls `search_for_templates` or `get_template` using the name you provided. If you said "Client Intake template," it finds that by name and retrieves the template ID. If multiple templates match, it asks you to confirm which one before proceeding. **Step 2 - Read what already exists** Before creating anything, the AI calls `get_kickoff_fields` (if you're adding to the kick-off form) or `get_template_steps` followed by the relevant step data (if you're adding to a specific step). This prevents duplicate fields - if "Client Name" already exists, the AI skips it rather than creating a second one. **Step 3 - Map your field descriptions to Tallyfy field types** This is where the translation happens. Tallyfy has a defined set of field types, and your AI maps your descriptions to them: | What you write | Tallyfy field type | |---|---| | text, short answer, string | Text field | | long text, paragraph, textarea | Textarea field | | dropdown, multiple choice, select | Dropdown field | | date | Date field | | yes/no, boolean | Radio or dropdown (Yes/No) | | checkboxes, multi-select | Multi-select field | | number, integer, currency | Number field | | email | Text field (email validation) | | file, attachment | File upload field | If you describe a field ambiguously - just "Contact" without a type - the AI defaults to text and tells you that's what it used. You can always change it afterward. **Step 4 - Create the fields** The AI calls `add_form_field_to_step` for each field in sequence. Fields are created in the order you listed them, which becomes their display order in the form. For dropdown fields, it calls `update_dropdown_options` immediately after creating the field to set the available choices. Required fields get a separate `update_form_field` call to mark them as required. **Step 5 - Confirm what was created** Once all fields are created, the AI returns a summary - something like "Added 10 fields to the Client Intake kick-off form. Vendor Name, Primary Contact, and Contact Email are required. Country and Department are dropdowns." You can verify this matches your original list before anyone starts using the template. ### Tips for better results **Specify the field type inline.** The more explicit you are, the more accurate the result. "Industry (dropdown)" is clearer than just "Industry." If it's a dropdown, list the options too: "Industry (dropdown: Healthcare, Finance, Retail, Technology, Other)." This saves a follow-up call to add the options. **Mark required fields explicitly.** Write "required" next to any field that must be completed before submission, or list them separately at the end: "Make Client Name, Email, and Company required." The AI picks up both formats. **Name the template and location precisely.** Tallyfy templates have exact names and can have many steps. "Step 2 Vendor Assessment on the Vendor Onboarding template" is unambiguous. "The vendor form" isn't. If you're not sure of the exact step name, ask first: "What steps are in the Vendor Onboarding template?" **Tell it whether you want kick-off fields or step fields.** These are different locations in Tallyfy - kick-off fields are collected before the process starts, step fields are collected when a specific task is completed. Be explicit about which one you want. **Paste from your source as-is.** You don't need to reformat your Google Form export, PDF field list, or spreadsheet headers before pasting. The AI handles various formats - comma-separated, pipe-delimited, numbered lists, bullet points. Just include a clear indication of field types where you have them. **For large forms, break it into batches.** If you have 30+ fields, consider splitting the request into two or three prompts - maybe grouped by section. This reduces the chance of any single field being missed and makes the confirmation output easier to review. **If dropdown options aren't final yet, say so.** "Create these as dropdowns - I'll add the options separately" tells the AI to create empty dropdowns that you can populate later. This is useful when you're still deciding on the option values. **Check the field order after creation.** Fields are added in the order you listed them. If your original form had a specific logical flow, make sure your list reflects that before pasting. Reordering fields after creation is possible in the template builder, but it's easier to get it right the first time. ### What good output looks like After you paste your field list and send the prompt, expect a confirmation like this: > "I found the Client Intake template and added 10 fields to the kick-off form: > > - Client Name (text, required) > - Company (text, required) > - Email (text, required) > - Phone (text) > - Country (dropdown: US, UK, Canada, Australia, Germany, France, Other) > - Department (dropdown: Sales, Marketing, Engineering, Support, Finance, HR) > - Project Type (dropdown: New Implementation, Migration, Consulting, Training) > - Start Date (date) > - Budget Range (dropdown: Under $10K, $10K-$50K, $50K-$100K, Over $100K) > - Additional Notes (textarea) > > All fields are now live on the template's kick-off form." That summary is worth reviewing against your original list - check the types, the dropdown options, and which fields are required. If something looks off, you can tell the AI to fix it: "Change Budget Range to a text field" or "Add 'Other' as an option to the Department dropdown." ### When this saves the most time **Migrating from paper forms.** You have a PDF intake form that's been in use for years. Type out the field names and types, paste them in, and the AI rebuilds that form as a Tallyfy kick-off in a few minutes - no clicking through the field builder for each one. **Converting Google Forms.** Google Forms exports a list of questions with types. Paste that list, tell the AI it's for your template's kick-off or a specific step, and it recreates the structure in Tallyfy. No manual translation required. **Using spreadsheet column headers as form fields.** If you track process intake data in a spreadsheet, the column headers are already a field list. Copy them, note which are dropdowns and which are free text, paste into your AI. The Tallyfy form mirrors the spreadsheet structure. **Standardizing forms across templates.** You have a set of client-facing fields that should appear consistently across several templates. Build the list once, then send the same prompt to each template in sequence: "Add these fields to the Client Intake template... now add them to the Contract Review template... now the Client Offboarding template." Same fields, same types, consistent across all three. **After a process redesign.** Your team overhauled an onboarding workflow and the new version needs different data collected at kick-off. Rather than clicking through the template builder to remove old fields and add new ones, paste the new field list and ask the AI to rebuild the kick-off form from scratch. ### Handling field types your source doesn't specify Not every form you import from will have explicit type labels. If your source just lists field names without types - "Vendor Name, Contact Email, Industry, Annual Revenue, Risk Level" - the AI will infer reasonable types based on the name: - Fields named with "email", "e-mail" → text field - Fields named with "date", "start", "end", "deadline" → date field - Fields ending in "amount", "value", "revenue", "budget" → number field - Fields like "notes", "comments", "description", "justification" → textarea - Everything else → text field by default The AI will tell you what it inferred for each field. If "Risk Level" should be a dropdown (Low/Medium/High) but the AI created it as a text field, tell it: "Change Risk Level to a dropdown with options: Low, Medium, High." One correction, done. ### Take it further - [Import a document as a template](/products/pro/integrations/byo-ai/use-cases/import-a-document-as-a-template/) - [Build a template through conversation](/products/pro/integrations/byo-ai/use-cases/build-a-template-through-conversation/) - [Merge and combine templates](/products/pro/integrations/byo-ai/use-cases/merge-and-combine-templates/) - **[Insert data into form fields from other systems](https://tallyfy.com/products/pro/integrations/byo-ai/use-cases/insert-data-into-form-fields-from-other-systems/)**: Paste raw data from emails, spreadsheets, CRMs, or PDFs into your AI chat. It'll automatically map and fill the correct form fields on your Tallyfy tasks without any manual copy-pasting. ## Stop retyping data that already exists You have client details in an email, pricing in a spreadsheet, or contact info in your CRM. Instead of manually copying each field into Tallyfy, paste the raw data into your AI chat and tell it which task to fill in. Done. ### What you'll accomplish - Fill Tallyfy form fields with data from any external source - Eliminate manual copy-paste between systems - Map unstructured data to structured form fields automatically ### Try it now What happens when you send one of these prompts: the AI calls `search_for_processes` to find the right process, then `get_tasks_for_process` to locate the specific task. It reads the form fields on that task, maps your pasted data to the correct fields, and calls `update_task` to fill them in. The whole thing takes a few seconds. ### How it works behind the scenes There's a short chain of steps your AI runs every time you paste data and ask it to fill a Tallyfy form. **Step 1 - Find the right process** The AI calls `search_for_processes` using the name or keywords you gave it - "Brightside Solutions onboarding" in the example above. This returns the matching process and its ID. If there are multiple matches (say you have several onboarding processes with similar names), the AI asks you to confirm which one before proceeding. **Step 2 - Locate the specific task** Next, `get_tasks_for_process` pulls all the tasks in that process. The AI scans for the one you named - "Client Details" in our example - and reads its form field definitions. This is the key step: before it writes anything, it knows exactly what fields exist, what type each one is (text, dropdown, date, number), and what options are available for any dropdowns. **Step 3 - Map your data to the fields** This is where the AI does the real work. It reads your pasted text and matches each piece to the most appropriate form field. A few things to know about how it handles edge cases: - **Dropdowns**: The AI matches your text to the closest available option. "Healthcare" might map to a dropdown option called "Health & Life Sciences" - and it tells you that's what it did. - **Dates**: Different formats (March 1, 2026 / 2026-03-01 / 01/03/2026) all get converted to whatever format the field expects. - **Currency**: "$2.3M" gets interpreted as a numeric value if the field is a number type. - **Ambiguous data**: If something could map to two different fields, the AI asks rather than guessing. **Step 4 - Write the values** Finally, `update_task` writes all the mapped values into the form fields in one call. You get a confirmation showing what was filled in where, so you can verify the mapping looks right. ### Tips for better results **Name the process and task as they appear in Tallyfy.** The AI searches by name, so "Client Details task in the Brightside Solutions onboarding" works much better than "that form in the new client thing." Copy the process name and task name from Tallyfy if you're not sure what they're called. **Paste raw data as-is.** You don't need to reformat your email, CRM export, or spreadsheet row into a clean structure. The AI is good at picking out the relevant data from messy text. The exception is if your source has a lot of irrelevant information - trim it down to just the fields you actually want to fill. **Label ambiguous data.** If you're pasting something that could be interpreted multiple ways, add a quick label. "Revenue: $2.3M" is clearer than just "$2.3M" floating in a paragraph. Takes two seconds and prevents a wrong mapping. **Works for partial updates too.** You don't have to fill every field in one go. "Update just the phone number and contract start date on the Client Details task" is completely valid. The AI fills only what you specify and leaves everything else alone. **For bulk operations, be explicit about scope.** "I have 5 client records, fill in the Client Details task for each matching process" works - but name each process clearly so the AI can find them. If the process names are predictable (like "Acme Corp Onboarding", "Bright Solutions Onboarding"), paste the full list and it handles the matching. **Check dropdown options before you paste.** If you know a field has a dropdown and your data uses different terminology than Tallyfy's options (e.g., your CRM says "SMB" but Tallyfy's dropdown says "Small Business"), you can tell the AI upfront: "The Industry field uses these options: Healthcare, Finance, Retail, Technology, Other." This eliminates any guesswork. ### What good output looks like After you paste your data and send the prompt, expect the AI to confirm what it did - something like this: > "I found the Brightside Solutions onboarding process and located the Client Details task. Here's what I filled in: > > - Company Name: Brightside Solutions > - Primary Contact: Maria Chen > - Email: maria@brightside.io > - Phone: +1-555-0142 > - Industry: Healthcare (matched to dropdown option "Healthcare & Life Sciences") > - Annual Revenue: 2300000 (converted from $2.3M) > - Contract Start Date: 2026-03-01 > > All 7 fields have been updated. Want me to complete the task or leave it open for review?" That last question is useful - in Tallyfy, you can update a task without marking it complete. If the form still needs a human to review it before submission, leave it open. If the data is final and you want to move the process forward, tell the AI to complete it. ### When this saves the most time **After a sales call.** Your notes or CRM record are already full of the client details you just collected. Instead of switching to Tallyfy and retyping everything into the onboarding form, paste the CRM record into your AI and let it fill the task. **Processing inbound emails.** A new client emails their details - company name, contact, requirements. Paste the email directly and tell the AI which task to fill. No reformatting needed. **Importing from a spreadsheet.** You're migrating a batch of records from a spreadsheet into Tallyfy processes. Copy a row, paste it with the column headers, point the AI at the right task. Repeat for each row. Much faster than opening each task and typing by hand. **After a form submission from another tool.** You received data through a Google Form, Typeform, or your website's contact form. Paste the submission into your AI and route it to the right Tallyfy task. This is a lightweight integration that doesn't require any webhook configuration. **When you need to correct a field.** "The phone number on the Client Details task for Brightside is wrong - it should be +1-555-0199." One sentence. Done. You don't have to find the task, open it, locate the field, clear the old value, type the new one. ### Take it further Once you've filled your form fields, the natural next step is often to complete the task and move the process forward - or to launch a new process with the data already pre-populated. - [Launch processes with pre-filled data](/products/pro/integrations/byo-ai/use-cases/launch-processes-with-pre-filled-data/) - [Create tasks from meeting notes](/products/pro/integrations/byo-ai/use-cases/create-tasks-from-meeting-notes/) - [Import forms into kick-off or step fields](/products/pro/integrations/byo-ai/use-cases/import-forms-into-kick-off-or-step-fields/) - **[Launch processes with pre-filled data](https://tallyfy.com/products/pro/integrations/byo-ai/use-cases/launch-processes-with-pre-filled-data/)**: Tell your AI what process to launch in plain language. It finds the right Tallyfy template, pre-fills all kick-off form fields, and starts the process without manual searching or data entry. ## Start a workflow with one sentence Instead of opening Tallyfy, finding the right template, and filling in kick-off form fields one by one, just tell your AI what you need. Describe the details in plain language and it launches the process with everything pre-filled - no tab-switching, no manual data entry, no hunting for the right template name. ### What you'll accomplish - Launch any Tallyfy process template from your AI chat - Pre-fill kick-off form fields with data from your plain language description - Skip the manual template-finding and form-filling workflow ### Try it now ### How it works behind the scenes Three tool calls happen in sequence - and understanding each one helps you write better prompts. **Step 1: Find the template** Your AI calls `get_all_templates` or `search_for_templates` depending on how specific your prompt is. If you say "Client Onboarding," it searches for that by name. If you're not sure of the exact name - "the onboarding template we use for new enterprise clients" - the AI uses search to find the closest match and may ask you to confirm before proceeding. **Step 2: Discover the kick-off fields** Once the AI identifies the template, it calls `get_kickoff_fields` to see exactly what data that template collects at launch. This matters. Tallyfy templates vary - some have two fields, some have fifteen. The AI reads the actual field definitions: field names, field types (text, dropdown, number, date, email), which fields are required, and what the valid options are for dropdown fields. This step makes pre-filling accurate. Rather than guessing at field names, the AI knows precisely what the template expects. **Step 3: Launch with pre-filled data** Your AI calls `launch_process` with three things: the template ID it found in step one, a process name (usually derived from your description - something like "Client Onboarding - Acme Corp"), and the kick-off field values matched to the right field IDs. The matching logic is straightforward. If a field is labeled "Company name" and you said "Acme Corp," that's an obvious match. If a field is a dropdown for "Client tier" with options Enterprise, Business, and Starter, and you said "Enterprise tier client," the AI selects Enterprise. If a field expects an email address and you provided one, it goes there. What happens when data is ambiguous? The AI asks. If you said "50K" and the field expects a number, most AIs will interpret that as 50000 without asking. But if you mentioned a date range and the template has both a "contract start date" and a "contract end date" field, the AI will clarify which date goes where rather than guess. Required fields that are completely missing from your description will always trigger a question before the process launches. The AI won't skip required fields or leave them blank - it'll ask you to provide the missing information first. ### Tips for better results **Name the template precisely.** Tallyfy templates have exact names - "Client Onboarding" and "Enterprise Client Onboarding" could be two different templates. If you're not sure of the exact name, ask first: "What onboarding templates do we have?" The AI will list them and you can pick the right one. **Include all the data you want pre-filled.** The AI can only fill fields from information you provide. If the kick-off form has a "Sales rep" field and you don't mention who that is, the AI will either leave it blank (if it's optional) or ask you. Front-loading all the relevant details in your prompt saves a round-trip. **Ask what fields are available before launching.** If you're not sure what a template collects, ask: "What kick-off fields does the Client Onboarding template have?" The AI calls `get_kickoff_fields` and returns the full list. Then you can craft a prompt that covers everything. **Launch multiple processes at once.** You can describe several at the same time: "Launch Employee Onboarding for these three new hires: [names and details]." The AI will launch them sequentially, one per template instance, applying the right data to each. This is useful for batch work - onboarding a cohort of new hires, for example, or starting client processes for everyone who signed up this week. **Use copy-paste for structured data.** If you have a table or a list of new client details from a spreadsheet, paste it directly into your prompt. The AI handles unstructured input well, but tabular data with clear labels maps to form fields with almost no ambiguity. **Mix process launch with context.** You can include relevant background: "Launch the Contract Review template for Acme Corp. Note that their legal team requires two-week turnaround and they flagged data residency as a concern - include that in the notes field." As long as there's a notes or free-text field in the kick-off form, the AI will put that context there. ### What the AI does with dropdown fields Dropdown fields deserve a mention because they behave differently from text fields. When the kick-off form has a dropdown - say, "Client tier" with options Enterprise, Business, and Starter - the AI reads those options from `get_kickoff_fields` and matches your description to the closest one. If your description is unambiguous ("Enterprise tier"), the match is automatic. If it's ambiguous ("large client"), the AI will either pick what seems most likely and tell you what it chose, or ask you to confirm. Most AIs err toward asking rather than guessing on dropdowns, since picking the wrong option can affect how the process routes and who gets assigned. Date fields work similarly. If the form expects a specific date format, the AI handles the conversion - "next Monday" becomes an actual date, "end of Q2" becomes June 30. ### When the AI asks for confirmation Not everything launches automatically. Your AI will pause and ask before proceeding in a few situations: - **Required fields are missing** - if the form requires a field you didn't mention, the AI will ask for it rather than launch with gaps - **Template ambiguity** - if "Client Onboarding" matches multiple templates, the AI lists them and asks which one you mean - **Destructive interpretations** - if the AI is unsure whether a value belongs in one field or another, it asks rather than guesses - **Dropdown mismatches** - if your description doesn't clearly match any dropdown option, the AI shows you the options and asks you to pick This confirmation behavior is intentional. The whole point of pre-filling data is accuracy - a process launched with the wrong client tier or the wrong contract value creates downstream problems in Tallyfy that are harder to fix after the fact. ### After the process launches Once `launch_process` succeeds, Tallyfy creates a running process with all your kick-off data in place. The AI returns confirmation: the process name, its ID, and usually a direct link to open it in Tallyfy. From that point, the process runs like any other - Tallyfy assigns tasks to the right people based on the template's assignment rules, calculates deadlines, and sends notifications. The only difference from launching manually is that you never touched the Tallyfy interface. If you want to verify, ask: "What's the status of the Acme Corp onboarding process?" The AI will call the relevant tools to check and report back. ### Take it further - [Insert data into form fields from other systems](/products/pro/integrations/byo-ai/use-cases/insert-data-into-form-fields-from-other-systems/) - [Create tasks from meeting notes](/products/pro/integrations/byo-ai/use-cases/create-tasks-from-meeting-notes/) - [Build a template through conversation](/products/pro/integrations/byo-ai/use-cases/build-a-template-through-conversation/) ## For developers *(Skip this unless you're setting up the technical side.)* Underneath, `launch_process` posts to `POST /organizations/{org_id}/runs`. The kick-off values travel in a `prerun` object keyed by each field's timeline ID, a 32-character hex string: ```json { "checklist_id": "f7e6d5c4b3a2918070615243342516f0", "name": "Client Onboarding - Acme Corp", "prerun": { "a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6": "Acme Corp", "3c9d1e7fa4b820516d8e2f7a9c0b4d15": { "id": 2, "text": "Enterprise" }, "9f2b7c1e4a6d8035b1c7e9d2f4a6b801": "jane@acme.com" } } ``` That's why the `get_kickoff_fields` call in step 2 matters so much: it's where your AI picks up those IDs. A key that isn't a timeline ID matches no field, and Tallyfy drops it without raising an error. The process would launch looking perfectly healthy with the value quietly missing. The value format depends on the field type: | Field type | Value to send | |------------|---------------| | Short text, long text, email | A plain string | | Date | An ISO 8601 string, like `"2026-03-15T00:00:00.000Z"` | | Radio button | The option's text as a plain string | | Dropdown | An object with both keys: `{ "id": 2, "text": "Enterprise" }` | | Checklist (multi-select) | A list of those objects, each carrying `"selected": true`: `[{ "id": 1, "text": "Laptop", "selected": true }]` | | Table | A list with one entry per column, in column order: `["Widget", "3"]` | | Assignees | `{ "users": [], "guests": [], "groups": [] }` | Dropdown and radio look alike in the app but take different shapes here. A radio takes the bare text, a dropdown needs the `id` and `text` pair together. Watch the multi-select shape in particular. Drop the `"selected": true` flag and the value still saves without an error, but it renders as empty text everywhere the field is used as a `{{variable}}`. Tell your AI to include the flag on every option it picks. Each `prerun` value's shape depends on the field type. The per-type list lives on [Launch process](/products/pro/integrations/open-api/code-samples/processes/launch-process/). - **[Merge and combine templates](https://tallyfy.com/products/pro/integrations/byo-ai/use-cases/merge-and-combine-templates/)**: Tallyfy's AI integration lets you merge multiple workflow templates into one or split oversized templates apart through plain conversation. It reads all steps and form fields, detects duplicates, and preserves data without manual copy-pasting. ## Combine or split templates without starting over Two overlapping templates? One template that's grown too big? Your AI can merge multiple Tallyfy templates into one, pull specific steps from one into another, or split a template apart - all through conversation, without rebuilding from scratch. No exporting, no copying and pasting between tabs, no losing your form fields in the process. ### What you'll accomplish - Merge steps from two or more templates into a single combined template - Pull specific steps from one template into another - Handle duplicate steps, ordering conflicts, and form field overlaps ### Try it now ### How it works behind the scenes The AI works through a merge in a predictable sequence. Knowing the steps helps you write clearer prompts and spot potential issues before they happen. **Step 1: Read both source templates** The AI calls `get_template` and `get_template_steps` on every template involved in the merge. This pulls back the complete picture: every step name, description, step type (task, approval, email), position, assignees, groups, and every form field attached to each step. The AI doesn't assume anything - it reads what's actually in Tallyfy before deciding what to do with it. For a merge involving two templates with ten steps each, that's twenty steps with all their associated data read before the AI makes a single change. This is what makes the merge reliable rather than destructive. **Step 2: Clone one template as the starting point** Rather than creating a blank template and rebuilding everything, the AI calls `clone_template` on one of the source templates. The clone preserves all existing steps, form fields, descriptions, and assignments exactly as they are. From there, the AI only needs to add the steps from the second template - which is much less work and much less likely to introduce errors. Which template gets cloned first? Usually whichever one provides the "base" order you want - in the HR/IT example, the HR template gets cloned because you want HR steps first. **Step 3: Compare and identify duplicates** Before adding anything from the second template, the AI scans both step lists for duplicates. It looks at step names and descriptions, not just titles. A step called "Send welcome email" in one template and "Welcome email to new hire" in another might be functionally identical even though the names differ. When duplicates are found, the AI picks the more complete version - the one with the longer description, more form fields, or clearer instructions. It tells you which one it kept and which it skipped. If the versions are different enough that keeping both might make sense, the AI asks rather than deciding on its own. **Step 4: Add non-duplicate steps from the second template** For each step that doesn't already exist in the cloned template, the AI calls `add_step_to_template` to add it in the right position. Position matters - if you said "HR steps first, then IT steps," the IT steps land after all the HR steps, not interspersed. Then, for each added step, the AI calls `edit_description_on_step` if the descriptions need merging - say, both templates had a similar step but with different instructions, and you want to combine the best parts of both into a single description. **Step 5: Handle form fields from the added steps** Steps brought in from the second template carry their form fields with them - in theory. In practice, the AI calls `add_form_field_to_step` to explicitly recreate each field on the new step, since field definitions don't transfer automatically through a step copy. If both templates had a step with a "Client Name" field, the AI adds that field once and notes the duplicate. You don't end up with two "Client Name" fields on the same step. ### Handling conflicts Real merges don't always go smoothly. Here's what happens with the most common friction points. **Duplicate steps** Steps with similar names or content are flagged before anything is changed. The AI tells you what it found - "Both templates have a step called 'Send welcome email'. Template A's version has a longer description and three form fields. Template B's version has only a title. I'll keep Template A's version." You can override that decision if you prefer the other one. If the AI genuinely can't determine which version is better - they're different but neither is clearly more complete - it asks you. It won't silently pick one and move on. **Step ordering** You control the order by specifying it in your prompt. "HR steps first, then IT steps" is the simplest form. "Interleave budget steps and compliance steps alternately" is more complex but the AI handles it. If you don't specify an order, the AI uses the source templates' original order and puts the second template's steps after the first template's. For splits, you can specify by step number ("steps 1-8") or by step name ("everything up to and including the 'Contract Signed' step"). Either works. **Form field overlaps** The most common overlap is a field like "Client Name" or "Department" that exists on similar steps in both templates. When the AI finds this, it keeps one instance and notes the duplicate. The field that ends up on the merged step is the one from whichever template you cloned as the base - unless you specify otherwise in your prompt. Different field types are more nuanced. If one template has a "Notes" field as a short text field and the other has it as a long text area, the AI will flag the conflict and ask which type you want. These aren't things it guesses at. **Different step types** If one template has a step as a standard task and the other has a matching step as an approval, the AI asks which type you prefer before proceeding. An approval step routes through Tallyfy's approval logic - someone has to formally approve it before the process moves forward. A standard task just gets completed. These are meaningfully different, so the AI doesn't pick one silently. ### Tips for better results **Name both templates exactly as they appear in Tallyfy.** Template names are matched case-insensitively but the closer your prompt matches the actual name, the faster the AI finds the right template. If you're not sure of the exact name, ask first: "What templates do I have that relate to onboarding?" The AI will list them. **Specify the order explicitly.** "Template A steps first, then Template B" is unambiguous. "Merge them together" leaves the AI to guess what order you want, which may or may not match your intent. **Say what to do with duplicates before the AI asks.** "Remove any steps that appear in both templates" saves a round-trip. So does "Keep the version with the most detail if steps overlap." If you're fine with the AI deciding, you don't need to say anything - it'll ask when it's unsure. **Clone the originals first if the source templates matter.** If you want to keep the original templates intact after the merge, tell the AI: "Clone both templates first, then merge the clones. Don't change the originals." This way you can always go back to the pre-merge versions in Tallyfy. **For splits, specify which steps go where.** "Steps 1-8 into Template A, steps 9-15 into Template B" is clear. "The setup steps in one template and the training steps in another" works too, as long as there's a natural boundary the AI can identify. If the split point isn't obvious, the AI will ask you to clarify rather than guess. **Be explicit about form fields.** If specific form fields matter to you - "make sure the 'Contract Value' field from the Finance template transfers to the merged template" - say so. The AI always tries to preserve form fields, but calling out the critical ones means they won't get missed. **Ask for a plan before execution on complex merges.** For anything involving three or more templates, or an interleaved step order, add "Show me the proposed step order before you build anything" to your prompt. You get to review the plan and catch ordering mistakes before any changes land in Tallyfy. ### Take it further - [Import a document as a template](/products/pro/integrations/byo-ai/use-cases/import-a-document-as-a-template/) - if you're starting from a Word doc or SOP rather than existing templates, this is the faster path - [Audit and improve your templates](/products/pro/integrations/byo-ai/use-cases/audit-and-improve-your-templates/) - once your merged template is built, run it through an AI review to catch gaps, unclear steps, or missing assignments - [Build a template through conversation](/products/pro/integrations/byo-ai/use-cases/build-a-template-through-conversation/) - start from scratch through conversation instead of merging existing templates - **[Set up automation rules in plain language](https://tallyfy.com/products/pro/integrations/byo-ai/use-cases/set-up-automation-rules-in-plain-language/)**: Describe automation rules in plain language to your connected AI instead of using the automation builder. Your AI reads the template, checks for conflicts, and creates if-then rules for step visibility, assignments, and deadlines. ## Describe the rule - your AI builds the automation Tallyfy automations use if-then logic to route tasks, skip steps, change assignments, and trigger actions based on data in your processes. Instead of configuring these rules through the automation builder, just describe what you want in plain language. Your AI translates the business logic and creates the rules directly in your template. No menu hunting. No figuring out which condition type maps to which field. Just say what should happen and when. ### What you'll accomplish - Create automation rules by describing business logic in plain language - Set up conditional step visibility, assignment changes, and deadline adjustments - Skip the automation builder entirely ### Try it now ### How it works behind the scenes Your AI works through a predictable sequence every time you describe an automation rule. Understanding the steps helps you write better prompts. **Step 1: Read the template structure** Before creating anything, the AI calls `get_template` and `get_template_steps` to read the full template. It's looking for step IDs, form field IDs, existing assignments, and the field types that matter for your conditions. A field called "deal value" might be a number field, a currency field, or a text field - that distinction changes how the condition is written. **Step 2: Check for conflicts** The AI calls `analyze_template_automations` to scan existing rules. If a rule already hides the Legal Review step under a different condition, the AI flags it before creating a potentially contradictory rule. That's where describing your intent matters - "skip Legal Review for small deals" tells the AI something different than "always show Legal Review for enterprise customers," even if both involve the same step. **Step 3: Create each rule** The AI calls `create_automation_rule` for each condition you described. Each rule has two parts: - **Trigger condition**: which field value or event starts the rule (a dropdown selection, a number threshold, a date comparison, a checkbox state) - **Action**: what happens when the condition is true (hide a step, show a step, change an assignee, adjust a deadline) The AI maps your natural language to Tallyfy's automation types: - "skip step" / "hide step" → hide step automation - "show step" / "add step" → show step automation - "assign to" / "add approver" → assignment automation - "set deadline" → deadline automation **Step 4: Confirm what was created** Once the rules are created, the AI summarizes them in plain language so you can verify the logic before testing. Something like: "I created two rules. Rule 1 hides the Legal Review step when deal value is less than $10,000. Rule 2 adds VP of Sales as an approver on Final Approval when deal value is greater than $50,000." That confirmation is worth reading carefully - it's the fastest way to catch a misread condition before it affects live processes. ### Common automation patterns Different business scenarios map to different automation types in Tallyfy. Here's what each looks like in plain language. **Conditional step visibility** "If [field value matches condition], show/hide [step name]" This is the most common pattern. Steps that don't apply get hidden; steps needed in special cases get revealed. Real examples: - "If the department is HR, show the HRIS Access Setup step" - "If the project type is Internal, skip the Client Sign-off step" - "If the applicant answered No to the background check consent question, hide the Background Check step" The condition can be a dropdown selection, a checkbox, a number comparison, a date, or even whether a particular field was filled in at all. **Dynamic assignment** "If [condition], assign [step] to [person or group]" Route tasks to different people based on the data in your process. Useful when the same step should go to different approvers depending on deal size, department, geography, or any other field. - "If the region is EMEA, assign the Compliance Review step to the EU Legal team" - "If the budget exceeds $100,000, assign Final Approval to the CFO instead of the department head" - "If the ticket type is Security, add the Security team as an additional assignee" Note that assignment automations add or change assignees - they don't remove existing ones unless you specify that explicitly. **Deadline adjustments** "If [condition], set deadline to [time period]" Tighten or extend deadlines based on priority, urgency, or other criteria. The time period can be hours, business days, or calendar days. - "If priority is Critical, set all step deadlines to 4 hours" - "If the renewal date is within 30 days, set the Contract Review deadline to 1 business day" - "If the deal size is over $500,000, extend the Due Diligence deadline to 10 business days" **Multi-condition rules** "If [condition A] AND [condition B], then [action]" Combine conditions when a single field value isn't enough to trigger the right behavior. Both conditions must be true for the action to fire. - "If department is Sales AND deal size is over $50,000, add the Revenue Operations team to the Forecast Review step" - "If vendor type is New AND contract value is over $10,000, show the Extended Vetting step" The AI handles AND logic naturally when you describe it that way. If you need OR logic - where either condition alone should trigger the action - say "or" explicitly and the AI will create separate rules or ask how you want it structured. ### Tips for better results **Reference exact step names and field names from your template.** The AI reads your template to find matches, but "the approval step" is harder to resolve than "the Final Approval step." Field names matter too - "the amount field" and "the deal value field" might be different fields in your template. **Be explicit about thresholds.** "Greater than $50,000" and "at least $50,000" are different conditions. "Less than" and "up to" have edge cases at the boundary. State the exact threshold and whether the boundary value is included. **Ask the AI to check for conflicts.** Before creating new rules on a template that already has automations, say: "Check for any existing rules that might contradict this before creating it." The AI calls `analyze_template_automations` and flags anything worth reviewing. **Describe one logical group at a time.** If you have five unrelated rules, describe them in one prompt and let the AI work through them. But if you're setting up a complex routing system with overlapping conditions, take it one rule at a time and verify each one before adding the next. **Test the logic before going live.** After creating rules, ask: "What would happen if someone selected Engineering in the department field and filled in a start date 3 days from now?" The AI walks through which rules would fire and what the resulting step visibility and assignments would look like - without actually launching a process. **Specify the field value format your template uses.** If your priority dropdown uses "High / Medium / Low" but you say "urgent" in your prompt, the AI will either ask for clarification or try to map it. Save time by matching the exact option text from your form field. **Handle edge cases explicitly.** "If the deal value is over $50,000, add the VP of Sales as an approver" - but what happens for deals under $50,000? If you want the step assignment to stay as-is, that's fine. If you want a different assignee for smaller deals, say so. The AI won't assume what the else condition should be. ### Take it further - [Audit and improve your templates](/products/pro/integrations/byo-ai/use-cases/audit-and-improve-your-templates/) - [Build a template through conversation](/products/pro/integrations/byo-ai/use-cases/build-a-template-through-conversation/) - [Generate reports from process data](/products/pro/integrations/byo-ai/use-cases/generate-reports-from-process-data/) ### Cli - **[Authenticate the CLI](https://tallyfy.com/products/pro/integrations/cli/authentication/)**: Tallyfy CLI authentication takes one paste of a personal access token, stored safely in your computer's keychain. Scripts and CI jobs authenticate with an environment variable instead, and application tokens keep long-running automation stable. ## Signing in to Tallyfy from the command line Sign in once and the CLI remembers you. The login command opens your Tallyfy settings in a browser, you copy your personal access token, paste it into the terminal, and you're done. The token is checked against your account and then saved securely on your computer, so every command after that just works. It takes about a minute, and you only do it once per computer. Here's the command that starts the flow: ```bash tallyfy login ``` Prefer not to have a browser pop up? Add `--no-browser` and the CLI prints the URL instead. Your token lives at **Settings** > **Integrations** > **REST API** inside Tallyfy. The CLI stores the token in your operating system's keychain[^1], not in a plain text file. To remove it later, run `tallyfy logout`. ### Checking your identity Two commands tell you exactly who the CLI thinks you are: ```bash tallyfy whoami tallyfy auth status ``` `whoami` shows the signed-in user and active organization. `auth status` also shows *where* the credential came from, which matters once scripts enter the picture. ### How the CLI picks its credential You can hold credentials in more than one place. The CLI resolves them in this order, and the first match wins: 1. The `--api-key` flag passed on the command itself. 2. The `TALLYFY_API_TOKEN` environment variable. 3. A token returned by your `auth.apiKeyHelper` script, a setting that runs a command of yours to fetch a token. Useful when secrets live in a vault. 4. The token saved by `tallyfy login`. This layering means your saved login is the comfortable default, and automation can override it without touching your machine's keychain. ### Authenticating in CI and scripts Don't run the interactive login in a pipeline. Set the environment variable from your CI system's secret store instead: ```bash tallyfy process list ``` For unattended automation, use an **application token** rather than your personal one. Personal access tokens are invalidated when you log out of Tallyfy, which quietly breaks any pipeline still holding them. Application tokens are issued to your app, not to a person's session, so they keep working. See [third-party application API access](/products/pro/integrations/open-api/access-api-as-a-third-party-application-instead-of-a-user/) for how to get one. If you really need to save a token non-interactively, the login command reads from standard input: ```bash echo "$TOKEN" | tallyfy login --stdin ``` ### Headers are handled for you Tallyfy's API rejects requests that miss its required headers, and that's a common trip-up for people calling it raw. The CLI adds all of them automatically on every request, including the `X-Tallyfy-Client` header, so there's nothing to configure. Details on the raw requirements are in the [API documentation](/products/pro/integrations/open-api/). ### What about OAuth? OAuth sign-in (the browser-approval standard where you never paste a token at all) is on the roadmap for a future release. Today the CLI authenticates with the tokens described above. [^1]: On systems without a keychain, the CLI falls back to an encrypted file using AES-256-GCM. - **[Bulk operations](https://tallyfy.com/products/pro/integrations/cli/bulk-operations/)**: Tallyfy CLI launches hundreds of processes from one CSV file, previews every action with a dry run, paces itself around API rate limits, and reports partial failures with a distinct exit code so your scripts always know what happened. ## Launching many processes at once Launch two hundred processes with one command. You put one row per process in a spreadsheet, save it as a CSV file, and point the launch command at it. The Tallyfy CLI works through the list for you: it paces itself around rate limits, keeps going when a single row fails, and tells your script exactly how things went when it's done. ### The CSV file Each row launches one [process](/products/pro/tracking-and-tasks/processes/). The header row names the inputs: a `name` column sets the process name, and every other column is a [kick-off form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/). Name a field by its label (what you see on the form), by its alias, or by its field ID. A file for a customer onboarding blueprint might look like this: ```csv name,Customer email,Priority Onboard ACME Corp,contact@acme.example,High Onboard Beta LLC,ops@beta.example,Normal ``` Values follow the field's type. Text, date and email fields take the value as you'd write it. A dropdown or radio field takes the option's text, like `High`. A multi-select takes several option texts separated by commas. The CLI turns each one into the shape the API expects, so you don't have to. If a header doesn't match any kick-off field on that blueprint, the command stops before launching anything and prints the fields that do exist. That's deliberate. Fixing a column name takes a second, while discovering next week that two hundred processes launched with one column quietly missing does not. Run `tallyfy process launch --help` for the exact column reference for your version. ### Preview first, launch second `--dry-run` prints the API calls the CLI would make for every row without executing any of them. Check the count and spot-check a few values, then run it for real: ```bash tallyfy process launch --from-csv launches.csv --dry-run tallyfy process launch --from-csv launches.csv ``` The dry run resolves every header against the blueprint and prints the exact request it would send for each row. It costs nothing and catches the classic mistakes: a stale file, a missing column, a header that doesn't match a kick-off field, or a dropdown value that isn't one of the options. ### When some rows fail Big batches rarely fail all-or-nothing. If some rows launch and others don't, the CLI finishes the batch and exits with code 9, the dedicated partial-failure signal. Your script can branch on it: alert a person, log the run, and avoid blindly re-running the whole file, which would duplicate the processes that did launch. The full exit-code table is in [troubleshooting](/products/pro/integrations/cli/troubleshooting/), and [handling idempotency](/products/pro/integrations/handling-idempotency-in-webhooks-and-api/) explains duplicate-safety patterns in more depth. ### Rate limits are handled for you Tallyfy's API throttles bursts, and a 200-row launch is exactly the kind of burst it throttles. The CLI paces itself automatically when the API asks it to slow down, so big batches simply take a little longer instead of crashing partway. If a limit truly can't be worked around, the command exits with code 6 so your script knows to retry later. The limits themselves are described in the [API documentation](/products/pro/integrations/open-api/). :::note[Why not ask an AI to do this?] Tallyfy's [MCP server](/products/pro/integrations/mcp-server/) deliberately refuses bulk changes touching more than 5 items in one request. That's by design: conversation is a great interface for small, reviewed changes and a poor one for a 200-row job. When the work is bulk, the CLI is the intended tool. ::: ## For developers *(Skip this unless you're setting up the technical side.)* - Every list verb exports machine-readable output for reconciliation, for example `tallyfy process list -o csv > processes.csv` after a big launch. - Use `ndjson` output when you're streaming results into another tool one record at a time. - Unattended jobs should set the `TALLYFY_API_TOKEN` environment variable and pass `--yes` for any ask-level action, since the CLI never prompts without a terminal. See [CI/CD approval gates](/products/pro/integrations/cli/ci-cd-approval-gates/) for the headless rules. - `--quiet` trims the output down when you only care about the exit code. - **[CI/CD approval gates](https://tallyfy.com/products/pro/integrations/cli/ci-cd-approval-gates/)**: Tallyfy CLI turns human sign-off into a pipeline step. One command blocks your CI job until a named task is completed, so releases, deployments, and migrations wait for approval without anyone watching a dashboard or writing polling code. ## Making your pipeline wait for a person A deployment shouldn't go out just because the tests passed. Sometimes a person needs to say yes first: a release manager, a compliance officer, a customer. The Tallyfy CLI turns that sign-off into an ordinary pipeline step: one command that waits until a named Tallyfy task is completed, then lets the pipeline continue. The approver just completes a task, the same way they complete any other work. ### The one-line gate ```bash tallyfy task wait TASK_ID ``` The command blocks until that [task](/products/pro/tracking-and-tasks/tasks/) is marked complete, then exits successfully so the next pipeline step runs. If the wait can't succeed, the exit code says why, and your pipeline fails loudly instead of deploying quietly. ### What the approver sees Nothing new. The approval task lives in a normal Tallyfy process, so the approver finds it in their task list and email like everything else, with the full context your blueprint provides: form fields, links, comments, and history. They review, they complete the task, and your pipeline moves. There's a permanent record of who approved what, and when. ### Where the task ID comes from Two common patterns: - **Launch, then wait.** An earlier pipeline step launches your release process with `tallyfy process launch` and captures the approval task's ID from its output. - **A standing gate.** For recurring jobs, look up the right task at runtime with `tallyfy task list` and wait on it. ## For developers *(Skip this unless you're setting up the technical side.)* ### A GitHub Actions example ```yaml jobs: release: runs-on: ubuntu-latest steps: - name: Wait for release sign-off run: tallyfy task wait "$APPROVAL_TASK_ID" env: TALLYFY_API_TOKEN: ${{ secrets.TALLYFY_API_TOKEN }} - name: Deploy to production run: ./deploy.sh ``` Store the token as a CI secret, and prefer an application token over a personal one so the gate doesn't break when someone logs out. Details are in [authentication](/products/pro/integrations/cli/authentication/). ### Headless behavior Pipelines have no terminal, and the CLI is built for that: - With no terminal attached, the CLI turns on `--no-input` automatically. It never sits waiting on a prompt; it fails with a clear exit code instead. - Read verbs like `list`, `get`, and status checks are allowed by default, so a valid token is all a monitoring job needs. - Actions your permission rules mark as "ask" are denied in headless runs unless the command carries `--yes`. That's deliberate: a script must state its intent to do anything destructive. ### A read-only profile for CI A pipeline that only needs to watch shouldn't hold the power to change things. Permission rules use a Resource(verb) pattern with allow, ask, and deny lists, and deny always wins. A CI profile like this can observe tasks and processes but touch nothing: ```json { "permissions": { "allow": ["Task(list)", "Task(get)", "Process(list)", "Process(get)"], "deny": ["Blueprint(delete)", "Process(archive)", "User(disable)"] } } ``` The full rule syntax, the six settings scopes, and centrally managed policy are covered in [configuration and permissions](/products/pro/integrations/cli/configuration-and-permissions/). - **[CLI vs API vs MCP](https://tallyfy.com/products/pro/integrations/cli/cli-vs-api-vs-mcp/)**: Tallyfy gives you four ways to get work done. People click in the web app, your own software calls the REST API, AI assistants connect through the MCP server, and scripts drive the CLI. This guide explains what each surface does best and which one fits the job in front of you. ## Which Tallyfy surface should do the job? Every piece of work in Tallyfy goes through one of four doors. People use the web app. Software you build calls the REST API. AI assistants connect through the MCP server. Scripts, pipelines, and scheduled jobs drive the CLI. All four act on the same [processes](/products/pro/tracking-and-tasks/processes/), [tasks](/products/pro/tracking-and-tasks/tasks/), and [templates](/products/pro/documenting/templates/), under the same permissions, so the question is never which one is allowed - it's which one fits the job. The short version: a person doing the work belongs in the web app. Your own product or internal system belongs on the API. A plain-English request to an AI assistant goes through the MCP server. And anything repeatable, bulk, or unattended belongs to the CLI. ### The four surfaces at a glance | Surface | Driven by | Best at | Watch out for | |---|---|---|---| | Web app | People clicking. | Daily work, tracking, building templates visually. | Manual repetition. Two hundred launches means two hundred rounds of clicking. | | [REST API](/products/pro/integrations/open-api/) | Code you write and maintain. | Custom product integrations with full control over every request. | You own the code, the credentials, and the error handling. | | [MCP server](/products/pro/integrations/mcp-server/) | AI assistants in conversation. | Plain-English questions, small reviewed changes, analysis. | Deliberately refuses bulk changes touching more than 5 items. | | [CLI](/products/pro/integrations/cli/) | Scripts and pipelines. | Repeatable jobs, bulk work, CI/CD gates, multi-org routines. | Built for automators, not for visual tracking. | ### The web app: where people work The web app is Tallyfy's home for humans: launching a process now and then, completing tasks, tracking progress across the team, and building templates with a visual editor. If the work happens occasionally and a person is present, there's nothing to set up and nothing to script. The other three surfaces exist for the moments when clicking stops scaling. ### The REST API: the raw surface underneath Tallyfy is API-first, so the [REST API](/products/pro/integrations/open-api/) offers the same capability that powers the web app - and the other three surfaces are all built on top of it. Choose it directly when you're building Tallyfy into your own product or internal system and need full control over requests, responses, and data flow. The trade-off is that you write and maintain that code yourself, including authentication and retries. ### The MCP server: for AI assistants The [MCP server](/products/pro/integrations/mcp-server/) connects assistants like ChatGPT, Claude, Gemini, and Microsoft Copilot to your Tallyfy organization through MCP (Model Context Protocol), the open standard for wiring AI tools to business systems. It shines at conversation: ask which tasks are overdue, have a template analyzed, turn a flowchart into a draft process. It's tuned for interactive use with a person reviewing each change, which is why it deliberately refuses bulk changes touching more than 5 items in one request. That's a feature, not a gap - conversation is a great interface for judgment and a poor one for volume. ### The CLI: for scripts and repeatable work The [Tallyfy CLI](/products/pro/integrations/cli/) is the door for work that runs the same way every time, with or without a person present. It covers the jobs the other surfaces handle poorly: launching hundreds of processes from a CSV file with [bulk operations](/products/pro/integrations/cli/bulk-operations/), holding a deployment until someone approves with [CI/CD gates](/products/pro/integrations/cli/ci-cd-approval-gates/), keeping templates in version control with [workflows as code](/products/pro/integrations/cli/workflows-as-code/), and repeating one change across many organizations from a single script. Predictable exit codes and machine-readable output make it dependable inside pipelines. ### A quick decision guide - Launch 200 processes from a spreadsheet? The CLI, from a CSV file. - Pause a release until a person signs off? The CLI's task wait command in your pipeline. - Keep templates in git and promote them between organizations? The CLI's export and import. - Build Tallyfy features into your own product? The REST API. - Ask "which tasks are overdue for the sales team?" in plain English? The MCP server. - Turn a flowchart or policy document into a draft template? The MCP server, through your AI assistant. - Track work day to day and build templates visually? The web app. ### They combine well Most teams end up using several doors at once, because the surfaces hand off to each other naturally. A pipeline launches processes through the CLI, people complete the resulting tasks in the web app, and an AI assistant summarizes how the week went through the MCP server. Nothing conflicts, because everything runs through the same API underneath. And if you'd rather connect apps without code at all, [middleware platforms](/products/pro/integrations/middleware/) like Zapier and Power Automate are one more path built on that same foundation. ## For developers *(Skip this unless you're setting up the technical side.)* - All four surfaces execute against the same REST API and the same permission model, so an action a user can't perform in the web app fails identically through the API, the MCP server, or the CLI. - Credentials differ by surface: the API and the CLI authenticate with Tallyfy API tokens, while MCP clients sign users in through the MCP server's own secure authorization flow. The CLI stores its token in the OS keychain and reads `TALLYFY_API_TOKEN` in pipelines, as covered in [authentication](/products/pro/integrations/cli/authentication/). - The CLI bridges the surfaces. `tallyfy api` calls any endpoint its built-in verbs don't wrap, with headers, authentication, and retries applied for you. `tallyfy mcp` manages the MCP server entries in a project's `.tallyfy/mcp.json` so AI clients can discover them, and prints ready-made config blocks per client. - Choosing between wrapped verbs and raw calls: prefer `tallyfy blueprint`, `tallyfy process`, and friends for readability and safety rails, and drop to `tallyfy api` for endpoints the [command reference](/products/pro/integrations/cli/command-reference/) doesn't list. - **[Command reference](https://tallyfy.com/products/pro/integrations/cli/command-reference/)**: Tallyfy CLI commands follow one resource-plus-verb pattern with aliases matching both UI and API vocabulary. Choose table, JSON, CSV, or NDJSON output, save repeatable commands for your team, and call any API endpoint directly when you need to. ## How Tallyfy CLI commands work Every command follows the same shape: the tool name, then a resource, then a verb. Typing the resource first and the action second gets you almost everywhere: blueprint list shows your templates, task complete marks a task done, process launch starts a new process. Once that pattern clicks, you can guess most commands without reading a manual, and built-in help fills the gaps whenever you're unsure. ### Two vocabularies, both accepted Tallyfy's web app and Tallyfy's API use different words for the same things. The app says "blueprint" and "process"; the API says "checklist" and "run". The CLI leads with the app words and quietly accepts the API words as aliases, so people coming from either side feel at home. | CLI command | Accepted aliases | |---|---| | `blueprint` | `checklist` | | `process` | `runs` | | `user` | `member`, `members`, `users` | | `guest` | `guests` | | `group` | `groups` | | `folder` | `folders` | | `tag` | `tags` | | `config` | `settings` | ### Getting help Add `--help` to anything. `tallyfy --help` lists every command, `tallyfy task --help` lists the task verbs, and `tallyfy task wait --help` explains one verb in full. When something misbehaves, run `tallyfy doctor` first; it checks your setup end to end. ### Output for people and output for scripts Every command can print its results four ways with the `-o` flag: `table` for humans, `json` for programs, `csv` for spreadsheets, and `ndjson` (one JSON record per line) for streaming. The `--json` flag is a handy shorthand for `-o json`, and it pairs naturally with jq: ```bash tallyfy blueprint list --json | jq '.' tallyfy task list -o csv > my-tasks.csv ``` ### Saved commands for your team Long commands you run often can be saved by name in your project's `.tallyfy/commands` folder and shared through version control. Anyone on the team then runs them by name, passing values as parameters: ```bash tallyfy run weekly-report --param week=29 ``` That keeps the tricky flags written down once, instead of living in one person's shell history. ## For developers *(Skip this unless you're setting up the technical side.)* ### Resources and verbs | Resource | Verbs | |---|---| | `blueprint` | `list`, `get`, `create`, `update`, `delete`, `clone`, `publish`, `steps`, `export`, `import`, `automation` | | `process` | `list`, `get`, `launch`, `update`, `archive`, `reactivate`, `export` | | `task` | `list`, `get`, `complete`, `reopen`, `reassign`, `comment`, `wait` | | `user` | `list`, `invite`, `role`, `disable`, `enable` | | `guest` | `list`, `get`, `create`, `update` | | `group` | `list`, `create`, `update`, `delete` | | `folder` | `list`, `create`, `delete` | | `tag` | `list`, `create`, `update`, `delete` | | `org` | `list`, `current`, `use` | Standalone commands round out the surface: `login`, `logout`, `whoami`, `auth` (login, logout, status), `config`, `doctor`, `api`, `run`, `mcp`, `trust`, `update`, `version`, and `completion`. ### Global flags These work on every command: | Flag | What it does | |---|---| | `--org` | Target a specific organization ID, overriding the active org. | | `-o, --output` | Output format: `table`, `json`, `csv`, or `ndjson`. | | `--json` | Shorthand for `-o json`. | | `--dry-run` | Print the API calls a command would make without executing them. | | `-y, --yes` | Assume yes for prompts; required for destructive or ask-level actions in scripts. | | `--no-input` | Never prompt; fail instead. Turned on automatically when there's no terminal. | | `-q, --quiet` | Suppress non-essential output. | | `--no-color` | Disable color output. | | `--verbose` | Verbose request logging, with tokens redacted. | | `--api-key` | Pass an API token directly. Prefer the `TALLYFY_API_TOKEN` environment variable in scripts. | | `--base-url` | Change the API base URL from the default `https://api.tallyfy.com`. | | `--settings` | Extra settings: a path to a JSON file, or an inline JSON object. | ### Raw API access When a workflow needs an endpoint the built-in verbs don't wrap, `tallyfy api` calls any Tallyfy API path directly with the standard headers, authentication, and retry policy applied for you: ```bash tallyfy api GET me tallyfy api GET organizations/YOUR_ORG_ID/checklists tallyfy api GET organizations/YOUR_ORG_ID/runs --query status=active --query per_page=100 tallyfy api POST organizations/YOUR_ORG_ID/tags --input tag.json ``` Details worth knowing: - The path is relative to the API base URL, and no leading slash is needed. - `--query` adds a query parameter as key=value and repeats as many times as you like. - `--input` takes a file path for the request body, or `-` to read from standard input. - The response body is written to standard output verbatim. Non-2xx responses still print the body and map to the usual exit codes, like 5 for not-found and 7 for validation. ### Shell completion Tab completion is available for bash, zsh, fish, and PowerShell: ```bash source <(tallyfy completion bash) tallyfy completion zsh > "${fpath[1]}/_tallyfy" ``` ### Exit codes Every command finishes with a predictable exit code so scripts can branch on the outcome. The full table, from 0 for success through 9 for a partial bulk failure, lives in the [troubleshooting guide](/products/pro/integrations/cli/troubleshooting/). - **[Configuration and permissions](https://tallyfy.com/products/pro/integrations/cli/configuration-and-permissions/)**: Tallyfy CLI settings merge across six scopes, from built-in defaults to company-managed policy. Permission rules decide which commands run, ask, or get blocked, workspace trust keeps cloned repositories from running hooks, and one doctor command checks it all. ## Controlling what the Tallyfy CLI can do You can run the CLI with zero configuration and it behaves sensibly. But when a team shares it, or automation runs unattended, you'll want control: which organization commands target, which actions run freely, which ones ask first, and which are blocked outright. Settings and permission rules give you that control, and one command shows you exactly where every value came from. ### Six places settings can come from Settings merge across six scopes. Later scopes win for single values, so the list runs from weakest to strongest: 1. **Defaults** built into the CLI. 2. **User**: your personal settings, applied everywhere you use the CLI. 3. **Project**: settings in a workspace's `.tallyfy` folder, committed and shared with teammates. 4. **Local**: your personal overrides for one workspace, kept out of version control. 5. **Flags**: whatever you pass on the command line, including `--settings` with a JSON file or inline JSON. 6. **Managed**: policy your company sets centrally. It outranks everything. Two merge behaviors matter. Single values (like the default output format) simply get overridden by the stronger scope. List values (permissions, hooks, and MCP servers) merge across scopes instead, so a project can add rules without erasing yours. When a setting isn't doing what you expect, ask the CLI to show its work: ```bash tallyfy config list --show-sources ``` That lists every effective setting and which file set it. `tallyfy config get` prints one resolved value, and `tallyfy config set` writes a value into a chosen scope's settings file. ### Permission rules: allow, ask, or deny Every rule names a resource and a verb, like Task(complete) or Blueprint(delete), and assigns one of three answers: - **Allow**: the action runs without fuss. Read verbs like `list` and `get` are allowed by default. - **Ask**: the CLI asks you to confirm at the terminal. In a script with no terminal, ask becomes deny unless the command carries `--yes`. - **Deny**: the action is blocked. Deny always wins, no matter what another scope allows. This is how you give a shared automation account a narrow job: allow the two verbs it needs, deny the rest, and sleep fine. A ready-made read-only example lives in the [CI/CD approval gates](/products/pro/integrations/cli/ci-cd-approval-gates/) guide. ### Managed policy for IT teams The managed scope is for company-wide policy: it can force which organization the CLI targets and lock permission rules so individual users can't loosen them. Because managed sits above every other scope, a laptop's local settings can never override it. ### Hooks and workspace trust Hooks are your own scripts that run around CLI commands, and they can block a command from running at all. A blocked command exits with code 8, so automation notices. Because project hooks execute code on your machine, they're gated behind trust. Hooks defined in a workspace's `.tallyfy/settings.json` run only after you've explicitly trusted that workspace: ```bash tallyfy trust # trust the current workspace tallyfy trust status # is it trusted? tallyfy trust remove # revoke trust ``` The point: cloning a stranger's repository must never be enough to run commands on your computer just because you used the CLI inside it. ### Check the whole setup in one go `tallyfy doctor` runs read-only checks across configuration, credential source, API reachability, the active organization, permission-rule validity, and the credential backend, then reports what's healthy and what isn't. It's the first command to run when anything misbehaves. ## For developers *(Skip this unless you're setting up the technical side.)* A permissions block in a settings file looks like this, with rules merged across scopes and deny winning every conflict: ```json { "permissions": { "allow": ["Task(list)", "Task(get)", "Task(complete)"], "ask": ["Process(launch)"], "deny": ["Blueprint(delete)"] } } ``` Useful details: - The active organization is stored in the CLI's state file (state.json). Resolution order for org targeting: the `--org` flag, then an org setting, then the org chosen with `tallyfy org use`. A managed forceOrg policy overrides them all. - `--settings` accepts either a path to a JSON file or an inline JSON object, which is handy for one-off runs and CI jobs. - `tallyfy doctor` validates your permission rules, so run it after editing settings files by hand. - **[Troubleshoot the CLI](https://tallyfy.com/products/pro/integrations/cli/troubleshooting/)**: Tallyfy CLI problems usually start with the doctor command, which checks your setup end to end. Exit codes then tell you exactly what failed, and this guide walks through fixes for expired tokens, permission blocks, wrong organizations, rate limits, and blocked hooks. ## When a CLI command misbehaves Something failed, and you want the fastest route back to a working setup. Start with the built-in doctor. It checks everything the Tallyfy CLI depends on, reports what's healthy and what isn't, and changes nothing on your machine or in your account. Most failures then come down to a handful of patterns, and each pattern has a quick fix further down this page. ```bash tallyfy doctor ``` The doctor looks at your configuration files, the credential you're signed in with, whether Tallyfy's API is reachable, your active organization, the validity of your permission rules, and where your token is stored. Run it first whenever a command misbehaves, and run it again after editing settings files by hand. ### Read the exit code Every command finishes with a number that says how things went. Zero means success. Anything else names the failure, which is what makes the CLI safe to script against. Here's the full table: | Code | Meaning | First thing to try | |---|---|---| | 0 | Success. | Nothing to fix. | | 1 | Generic error. | Rerun with `--verbose` to see what happened. | | 2 | Usage error. | Check the flags and arguments against `--help`. | | 3 | Authentication failed. | Sign in again with `tallyfy login`. | | 4 | Blocked by a permission rule. | Review your permission rules. | | 5 | Not found. | Confirm the ID and the active organization. | | 6 | Rate limited. | Wait, then retry. The CLI already paced itself. | | 7 | Validation error. | Fix the field the error message names. | | 8 | Blocked by a hook. | Check your hooks and workspace trust. | | 9 | Partial bulk failure. | Review which rows failed before rerunning. | ### Signed in yesterday, failing today (exit code 3) Personal access tokens don't last forever. Logging out of Tallyfy in your browser invalidates your personal token, which quietly breaks the CLI and any script still holding it. Sign in again: ```bash tallyfy login ``` If a fresh login doesn't help, run `tallyfy auth status`. It shows which credential the CLI is actually using - a stale `TALLYFY_API_TOKEN` environment variable or an `--api-key` flag baked into a script overrides your fresh keychain login, so update the token where it really lives. For automation that must not break when people sign out, switch to an application token as covered in [authentication](/products/pro/integrations/cli/authentication/). ### The CLI refuses an action you're allowed to do (exit code 4) This one isn't Tallyfy saying no - it's your own guardrails. Permission rules mark each action as allow, ask, or deny, and deny always wins. In a script with no terminal, ask quietly becomes deny unless the command carries `--yes`. To find the rule and the file it came from: ```bash tallyfy config list --show-sources ``` Loosen the rule in the right scope, or pass `--yes` for ask-level actions in scripts. One exception: rules set by your company's managed policy can't be overridden locally, so if the source says managed, talk to your IT team. The full rule syntax lives in [configuration and permissions](/products/pro/integrations/cli/configuration-and-permissions/). ### It exists in the web app, but the CLI says not found (exit code 5) Nine times out of ten, you're pointed at the wrong organization. IDs belong to one organization, so a perfectly valid process ID comes back not-found while the CLI targets another org. Check and fix: ```bash tallyfy org current tallyfy org list tallyfy org use CORRECT_ORG_ID ``` For a one-off command, the `--org` flag overrides the active organization without changing it. One caveat: a forceOrg policy managed by your company outranks both. ### Big jobs slow down or stop (exit code 6) Tallyfy's API throttles bursts, and the CLI already handles the normal case: it paces itself and retries when the API asks it to wait, so large batches just take a little longer. Exit code 6 appears only when a limit genuinely can't be worked around - usually an hourly cap, like invites to new guests. Wait for the window to reset, then rerun. The limits themselves are described in the [API documentation](/products/pro/integrations/open-api/). ### A hook stopped the command (exit code 8) Hooks are scripts you or your company attach around CLI commands, and a hook can veto a command outright. Exit code 8 means one did. Check which hooks your settings files define, and remember that project hooks only run in workspaces you've explicitly trusted - `tallyfy trust status` tells you where you stand. A hook enforced by managed policy is deliberate; ask whoever set it. ### Keep the CLI updated Old versions miss fixes, so when something odd happens, confirm what you're running and whether a newer release exists: ```bash tallyfy version tallyfy update --check tallyfy update ``` `--check` reports whether an update is available without installing anything. A plain `tallyfy update` downloads the new release, verifies it against the published checksums, and swaps it in atomically. Two notes: - If you installed through Homebrew, the CLI directs you to `brew upgrade` instead of self-updating - The `--channel` flag switches between the `stable` and `latest` release channels, and your default channel comes from settings ### macOS quarantines a downloaded binary Version 0.1.0 binaries aren't code-signed yet, so when you download one directly (rather than through Homebrew, which handles this for you), macOS may refuse to run it. The one-line fix: ```bash xattr -dr com.apple.quarantine ./tallyfy ``` ### Where to report a problem Found a bug, or hit something this page doesn't cover? File an issue at [github.com/tallyfy/cli/issues](https://github.com/tallyfy/cli/issues)[1]. Include the output of `tallyfy version` and the failing command run with `--verbose` - verbose logs redact your tokens, so they're safe to share. ## For developers *(Skip this unless you're setting up the technical side.)* Exit codes 0 through 9 are a stable contract, so scripts can branch on them: ```bash tallyfy process launch --from-csv launches.csv case $? in 0) echo "all launched" ;; 6) echo "rate limited - retry later" ;; 9) echo "some rows failed - reconcile before rerunning" ;; *) echo "launch failed" ;; esac ``` Debugging details worth knowing: - `--verbose` logs every request with tokens redacted. - `--dry-run` prints the API calls a command would make without executing them, which cleanly separates "wrong command" from "API problem". - With no terminal attached, the CLI turns on `--no-input` automatically and never sits waiting on a prompt. Ask-level actions are denied unless the command carries `--yes`. - Credentials resolve in a fixed order: the `--api-key` flag, then `TALLYFY_API_TOKEN`, then your `auth.apiKeyHelper` script, then the token saved by `tallyfy login`. `tallyfy auth status` names the source in use, which settles most wrong-identity mysteries. - **[Workflows as code](https://tallyfy.com/products/pro/integrations/cli/workflows-as-code/)**: Tallyfy blueprints export to clean JSON files you can keep in git, review like code, and import into other organizations. Build a promotion pipeline from a sandbox to production and schedule nightly template snapshots with the Tallyfy CLI. ## Treating Tallyfy templates like source code Export any blueprint to a JSON file, keep that file in version control, and review changes to your processes the same way your team reviews code. When a template is ready, import it into another organization. That's the whole promotion story: build in a sandbox organization, review the change in git, then ship the approved version to production. ### Why teams do this - **History and accountability.** Every change to a [template](/products/pro/documenting/templates/) gets an author, a date, and a reason, and you can roll back to any earlier version. - **Review before it goes live.** A pull request on a template change catches mistakes before they reach the people running the process. - **Identical templates everywhere.** Franchises, regional subsidiaries, and client organizations can all run the exact same approved blueprint. - **Cheap insurance.** A folder of exported JSON files is a complete, restorable backup of your process designs. ### The export, review, import loop Export writes a blueprint as git-committable JSON. Find the blueprint's ID with `tallyfy blueprint list`, then: ```bash tallyfy blueprint export BLUEPRINT_ID > client-onboarding.json ``` Commit that file, open a pull request, and let a teammate review the change like any other code. Once it's approved, import it into the target organization. Do a dry run first: ```bash tallyfy blueprint import client-onboarding.json --org PRODUCTION_ORG_ID --dry-run tallyfy blueprint import client-onboarding.json --org PRODUCTION_ORG_ID ``` `--dry-run` prints the API calls the CLI would make without executing any of them, so you can confirm exactly what's about to change. Nothing is written until you run the command again without the flag. :::note[Sandbox first] Keep a separate Tallyfy organization as your sandbox. Design and test there, export when it works, and only import reviewed files into the organization your team actually uses. ::: ## For developers *(Skip this unless you're setting up the technical side.)* ### Promote to many organizations The `--org` global flag targets any organization you belong to, so promoting one approved blueprint to a whole fleet is a shell loop: ```bash for org in ORG_US ORG_UK ORG_APAC; do tallyfy blueprint import client-onboarding.json --org "$org" --yes done ``` Add `--yes` in scripts so confirmation prompts don't stop the loop. Without it, the CLI refuses ask-level actions when no one's at the terminal. ### Scheduled snapshots A nightly export gives you a versioned history of every template, even changes made in the web app. Keep the blueprint IDs you care about in a file and let your scheduler run: ```bash while read -r id; do tallyfy blueprint export "$id" > "backups/$id.json" done < blueprint-ids.txt ``` Commit the results and your git history becomes a daily changelog of your process designs. Use `tallyfy blueprint list --json` to build the ID list programmatically. ### Good habits - Format and diff the JSON like any other code so reviews stay readable. - One blueprint per file, named after the template, so changes are easy to spot. - Run imports from CI with the `TALLYFY_API_TOKEN` environment variable, as covered in [authentication](/products/pro/integrations/cli/authentication/). - Preview every import with `--dry-run` before the real run. ### 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 AI automation on your own hardware, so data stays private and there are no per-use cloud costs. Tallyfy pairs small local models with structured, trackable workflows to automate mundane tasks like form filling. ## Run AI automation on your own computers A local computer use agent is AI that runs on your own computers instead of the cloud. It looks at the screen, clicks, types, and reads, just like a person would, to do routine screen-based work. Because everything runs on your hardware, your data never leaves the building. That's the big draw for most businesses. No screenshots or customer data sent to an outside service. No per-use fees. It keeps working even when the internet is down. Tallyfy is building support for this, so you can hand a local agent a task and track what it does, the same way you track any other work. This is early and advanced. Today it's most useful for the small, boring jobs that eat up people's time. :::warning[Start small with local AI agents] Put your step-by-step instructions for the agent in the Tallyfy [task](/products/pro/tracking-and-tasks/tasks/) description. **Start with short, bite-size jobs that are just mundane and tedious**, like filling a form or copying data between screens. Don't ask an AI agent to handle big, complex, goal-driven work yet. Agents are still unpredictable on hard tasks, they make things up, and costs add up fast. A small AI model is plenty for routine jobs. You don't need a giant model (or an expensive graphics card) to fill a form or pull data off an invoice, and the small one is faster. ::: ## Why run agents locally - **Privacy.** Screen captures, business data, and your workflows never leave your premises. - **No per-use costs.** Once it's set up, a local agent runs without paying per task or per token. - **Works offline.** No internet connection required. - **Compliance.** For rules like GDPR and HIPAA, keeping data in-house is often a must. Healthcare, finance, and government teams need automation that never sends data outside. - **Speed.** Running on your own hardware skips the network round-trip, so each step is quicker. The trade-off: you need a reasonably capable computer. The good news is that small models handle most everyday business tasks well, and they run on ordinary hardware. ## How it works The agent runs a simple loop. It looks at the screen, decides what to do next, does it, and checks the result. Then it repeats until the job is done. [Diagram removed for brevity] Each loop takes a few seconds, depending on your hardware and the model. The agent keeps going until it reaches the goal or hits a stopping point you set. ## Small models are usually enough Bigger isn't better here. Small AI models are great at the structured, repetitive tasks that make up most office work, like form filling, data extraction, and routine data entry. Tallyfy's approach puts reliability first. A simple agent that finishes a mundane task every time beats a clever one that crashes halfway through your invoice run. Pick the smallest model that does the job: - A tiny model can sort tasks by type or read a form. - A small-to-mid model handles most everyday automation. - A larger model is only worth it for the occasional complex case. Many capable open models are free to run locally, in a range of sizes. Your IT team can match the size to the task (see the technical notes below). ## Using local agents with Tallyfy Tallyfy is the control layer. It hands the agent a clear task and the data to work with, the agent does the work on your machine, and the results come back into Tallyfy, fully tracked. [Diagram removed for brevity] When a Tallyfy task needs computer work, the agent gets the step-by-step instructions from the task description and the input data from your [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/). It does the work, then returns the results into Tallyfy along with a log of what it did. You get real-time progress, an audit trail, and human approval checkpoints for anything important. Here's a simple example. A Tallyfy step says "get last month's invoices from the supplier portal." The agent logs in, filters to last month, reads the invoice number, amount, and due date off each one, and drops that data back into the right Tallyfy fields, with the PDFs attached to the process. ## Keeping it safe A local agent can do anything a person at the keyboard can, so guardrails matter: - **Approval gates.** Require a human "yes" before anything sensitive, like sending an email, deleting a file, or making a payment. - **Sandboxing.** Run the agent in an isolated environment with limited access. - **Audit logging.** Keep a full record of every action for compliance and debugging. - **Emergency stop.** Shut the agent down and roll back at any time. Smaller models help here too. Their behavior is more predictable, which is exactly what you want for routine work. ## Is it worth it? Over time, local agents usually cost less than cloud automation tools, which charge ongoing subscription or per-use fees. After you've covered the hardware, routine automation essentially runs for free. Tallyfy plans to charge a simple per-minute rate for active agent time, so you only pay when an agent is actually working. One honest caveat: research from MIT found that most AI pilots fail to deliver real savings. The ones that succeed share a pattern. They target small, well-defined back-office tasks, use focused models instead of general-purpose AI, and measure results from day one. So start with one repetitive task, prove the value, then expand. ## For your IT team *(Skip this unless you're setting up the technical side.)* **How an agent is put together.** Four pieces work together: a vision-language model (the "brain" that reads screenshots and decides actions), screen capture with OCR, an action engine that performs clicks and keystrokes, and an orchestration loop that runs the perceive-reason-act cycle, handles errors, and talks to Tallyfy. **Cross-platform.** Local agents work on Windows, macOS, and Linux. The most reliable setups combine screenshot-based vision with each OS's native automation layer (Windows UI Automation, the macOS Accessibility API, or Linux AT-SPI) and fall back to vision when needed. **Hardware, roughly.** Small models (about 1B to 8B parameters) run comfortably on a normal laptop or a graphics card with 4 to 12 GB of memory. Larger models (32B and up) want 24 GB or more. Quantization (a compression step) cuts a model's memory use significantly with little quality loss, so you can run bigger models on smaller hardware. **Models worth a look.** Many strong open models run locally, including small multimodal ones built for modest hardware (for example, Google's Gemma family) and compact general models from the Llama, Qwen, and Phi families. Match the size to the task rather than reaching for the biggest one. **Getting started.** A tool like Ollama lets you download and run these models locally with a single command. Start with one model and one repetitive task, integrate it with Tallyfy for coordination and tracking, measure the time saved, then scale up. **Frameworks and research.** Production-ready local agents build on open work like Microsoft's UFO2 (Windows), ScreenAgent (cross-platform), and Hugging Face's open computer agent, plus local inference engines such as Ollama, vLLM, and llama.cpp. - **[RPA vs. computer AI agents](https://tallyfy.com/products/pro/integrations/computer-ai-agents/rpa-vs-computer-use-agents/)**: RPA bots follow fixed rules for repetitive tasks but break when anything changes. Computer AI agents use language models and vision to adapt dynamically, and Tallyfy orchestrates both types in a single workflow with human checkpoints. ## RPA vs. computer AI agents RPA and computer AI agents both automate tasks - but they're worlds apart in what they can do. RPA[^1] follows a fixed script step by step. An AI agent reads the screen and works things out as it goes, more like a person would. Pick the wrong one and you'll either burn money on overkill or spend every Monday fixing broken scripts. Tallyfy orchestrates both types, so knowing the difference matters. The quick rule: steady, repetitive work suits RPA, while messy, changing work suits an AI agent. [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.** Don't try to 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 "overhaul our entire customer service." ::: ### Robotic process automation (RPA): the rule-follower RPA bots copy what humans do on computers - but only for repetitive, rule-based work. Think of RPA as that coworker who follows directions perfectly but freezes when anything unexpected happens. * **Core function:** Automates high-volume, predictable tasks based on defined rules and structured inputs. * **Data handling:** Built for **structured data** - spreadsheets, databases, or standardized forms. * **How it works:** Bots interact with UIs or APIs by following developer-defined steps (e.g., "Open app X, click button Y at coordinates (100,250), copy from field Z, paste into app A"). * **Adaptability:** RPA is **not adaptive**. Move a button 10 pixels? The bot breaks. Rename a field? Broken. Anyone who's maintained RPA bots knows that Monday-morning feeling of 47 error notifications. * **Decision making:** Limited to simple IF/THEN rules (e.g., "IF field X = 'Approved', do Y, ELSE do Z"). Can't handle uncertainty or complex judgment. * **Cognitive skill:** Low. Follows instructions literally without understanding the *intent* behind actions. * **Best suited for:** * Legacy system integration where APIs aren't available * High-volume data entry or migration between systems with fixed UIs * Form filling with consistent layouts * Standardized report generation from structured sources * **Tallyfy integration:** Tallyfy can trigger RPA bots for specific [tasks](/products/pro/tracking-and-tasks/tasks/) within a larger [process](/products/pro/tracking-and-tasks/processes/). A Tallyfy task could tell an RPA bot to pull data from [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) and enter it into a legacy mainframe. Tallyfy manages the process flow, provides inputs, and tracks completion. ### Computer AI agents: the adaptive problem-solver Computer AI Agents (also called Agentic AI or Computer Use Agents) are a different beast entirely. They use Large Language Models to understand language and computer vision to "see" what's on screen - much more human-like than RPA. * **Core function:** Automates complex, changing tasks that need context, interpretation of varied inputs (including unstructured data), planning, and decision-making toward a goal. * **Data handling:** Processes both **structured and unstructured data** - emails, web pages, PDFs, on-screen elements, and natural language instructions. * **How it works:** You give a goal in plain language (e.g., "Find the contact details for the main distributor of Product X in Germany and update their CRM record"). The agent then plans and executes - browsing the web, finding UI elements, filling forms, and typing text. * **Adaptability:** AI Agents are **much more adaptive**. They understand what elements mean, not just where they sit. Button moved? They'll find it. "Submit" changed to "Send"? They get it. It's like having an intern who can think instead of memorizing click coordinates. * **Decision making:** Makes context-aware decisions, handles uncertainty, and re-plans when hitting obstacles. * **Cognitive skill:** Higher. Interprets instructions, understands context, and works toward goals rather than running a fixed click sequence. * **Best suited for:** * Dynamic web apps or sites with frequently changing UIs * Extracting information from unstructured sources (e.g., scraping varied product pages) * Tasks requiring interpretation of on-screen information * Open-ended research and data gathering from web sources * Handling exceptions in a process flow * **Tallyfy integration:** Tallyfy defines a task goal (e.g., "Log into the supplier portal for Supplier Y, find all POs from last month for 'Project Alpha', and extract totals and delivery dates") and provides input data. The AI Agent carries out the web interactions. Tallyfy makes this a **Trackable AI** step - managing inputs, expected outputs, and human oversight within the overall process. ### Key differences at a glance | 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 toward agentic workflows * **Agentic workflows:** AI Agents plan, execute, and adapt to hit a goal. RPA just follows its script line by line. * **Accessible automation:** You can tell AI Agents what to do in plain English - no coding required. Tools like Microsoft Copilot Studio and OpenAI Operator are making automation available to everyone, not just developers. ### How Tallyfy orchestrates both Stable, high-volume tasks? Use RPA. Messy, real-world web interactions? AI Agents. Either way, Tallyfy gives you the structure to manage it: * **Clear process definition:** Document every step - whether human, RPA, or AI Agent. * **Input/output management:** Feed structured data to your automations and capture results in Tallyfy [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/). * **Human-in-the-loop:** Add human checkpoints for review and approval. When RPA hits an exception or AI makes a big call, humans step in. * **Trackable AI:** Every automated action is visible and accountable. Monitor performance and improve over time. * **Mixed automation:** Combine 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 and the human element Computer AI Agents aren't perfect. They still make mistakes, misread instructions, and get confused by edge cases. Impressive - but not magic (yet). That's why Tallyfy's human oversight matters. Design workflows with human checkpoints for critical decisions or external actions. You get AI automation's speed while keeping control where it counts. The bottom line: it's not RPA vs. AI Agents. The smartest approach uses both. RPA handles the predictable stuff. AI Agents tackle dynamic web interactions that would break your RPA scripts. Tallyfy orchestrates the whole show. [^1]: RPA: robotic process automation - software bots that follow a fixed, pre-recorded script and break when a screen changes. - **[AI agent vendors](https://tallyfy.com/products/pro/integrations/computer-ai-agents/vendors/)**: AI agent vendors like OpenAI Operator, Claude Computer Use, Skyvern, and Twin.so can automate browser-based tasks. Tallyfy acts as the workflow layer that assigns small steps to these agents while routing failures to human reviewers. ## AI agent products - commercial and open source Here's what's available in the computer AI agent space right now. **Commercial options:** - **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, deployed with European SMBs **Open-source options:** - **Skyvern** - Strong WebVoyager benchmark performance, transparent per-step pricing - **Manus AI** - Autonomous task completion, invite-only access Each vendor targets different use cases. Some focus on consumer tasks, others on developer workflows. The vendor pages below cover their technology, benchmarks, and how to integrate them with Tallyfy - particularly for web tasks where no API exists. :::warning[Important guidance for AI agent tasks] Put your step-by-step instructions in the Tallyfy [task](/products/pro/tracking-and-tasks/tasks/) description. **Start with short, bite-size, easy tasks that are mundane and tedious.** Don't ask an AI agent to handle large, decision-driven jobs - they're prone to unpredictable behavior, hallucination, and costs can escalate fast. ::: Check out each vendor page for specifics: ### Vendors - **[Claude computer use](https://tallyfy.com/products/pro/integrations/computer-ai-agents/vendors/claude-computer-use/)**: Claude Computer Use lets an AI agent control a screen through screenshots and mouse and keyboard actions in a sandboxed Docker environment. Tallyfy sends the task and captures the results, so you can automate repetitive desktop and web UI work like form filling and legacy data extraction, with people kept in the loop. :::note[This changes fast] Claude Computer Use is evolving rapidly. Capabilities, pricing, and availability may change. Always check [Anthropic's official docs](https://docs.anthropic.com) for the latest. ::: ## Using Claude to complete tasks within Tallyfy Claude can 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, available through Anthropic's API, Amazon Bedrock, and Google Cloud Vertex AI. :::warning[Start small with AI agent tasks] Put your step-by-step instructions in the Tallyfy [task](/products/pro/tracking-and-tasks/tasks/) description. **Start with short, mundane tasks.** Don't ask an AI agent to handle huge, decision-driven jobs - they're prone to unpredictable behavior and hallucination, and costs add up fast. ::: :::info[Computer Use vs MCP integration] This article covers **Claude Computer Use** - where Claude sees and controls screens through screenshots, mouse movements, and keyboard actions. That's different from [Claude's MCP integration](/products/pro/integrations/mcp-server/claude-anthropic/), which gives text-based chat access to data sources and APIs. **When to use each:** - **Computer Use** (this article): Automating visual UI tasks - clicking buttons, filling forms, working through menus - **MCP Integration**: Data queries, API-based workflow management, text-based automation Both can complement each other in automation workflows. ::: ### How computer use works Rather than 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 done. - Results, logs, and screenshots get captured back into Tallyfy fields. ### Model support and performance **Models with computer use support:** - **Claude Sonnet 4.6** - Best balance of performance and cost for most automation - **Claude Opus 4.6** - Flagship model for the most demanding tasks - **Claude Haiku 4.5** - Lighter option for simpler, faster automation **Performance benchmarks (OSWorld[^3]):** - Sonnet 4.6 scores 72.5% - now matching human-level performance (72.4%) - Rapid improvement from earlier models (Sonnet 4.5 scored 61.4%) - Still experimental, so expect some errors on tricky UI interactions ### The agent loop Here's how Tallyfy coordinates Claude's computer use through an iterative loop - Claude perceives, acts, and gets feedback until your task is done. [Diagram removed for brevity] **What to notice:** - Tallyfy triggers your intermediary app via webhook[^1] with task data. - The loop between Claude and the sandbox continues until the task is done. - All tool execution happens in an isolated sandbox for security. ### Core components **Sandboxed environment:** The Docker container typically includes: - A virtual X11 display server (like Xvfb) for rendering the desktop - A lightweight Linux desktop environment - Pre-installed apps (Firefox, LibreOffice, text editors) - Your implementations of Anthropic's defined tools **Three core tools** (Anthropic-defined, you execute them): - **computer**: Mouse/keyboard actions (clicks, typing, scrolling, cursor movement) and taking screenshots - **text_editor**: View, create, and edit files - **bash**: Run shell commands in the sandbox ### Pricing **API pricing (verify current rates at [Anthropic's pricing page](https://docs.anthropic.com)):** - **Claude Sonnet 4.6**: $3 per million input tokens, $15 per million output tokens - **Claude Haiku 4.5**: $1 per million input tokens, $5 per million output tokens - Computer use adds extra tokens to each system prompt **Access requirements:** - Anthropic API key with sufficient credits - Available through Anthropic API, Amazon Bedrock, or Google Cloud Vertex AI - Docker needed for the reference implementation ### Real-world use cases Computer Use works well for specific automation scenarios. Early adopters include Asana, Canva, Replit, and DoorDash. **Good applications:** - Form filling across desktop apps - Extracting data from legacy systems without APIs - QA testing with synthetic test case generation - Multi-step workflows spanning multiple applications - Desktop file management tasks ### Current limitations Claude's computer use is still developing. Anthropic acknowledges these constraints: **Technical:** - **Latency**: tasks with dozens or hundreds of steps can be slow. - **Error-prone**: scrolling, dragging, and zooming remain challenging. - **Resolution**: it may struggle above 1024x768 or 1280x800 due to image scaling. - **Reliability**: some actions people do effortlessly are still hard for Claude. **Safety:** - Claude may follow instructions found on-screen, even if they conflict with yours. - There's a risk of prompt injection from webpages or images. - There's potential for misuse if it isn't properly isolated. **Rate limits:** - API rate limits apply based on your tier. - Processing time varies with task complexity. ### Getting started You'll need to build an intermediary app that connects Tallyfy to the Anthropic API. Anthropic provides a reference implementation with Docker. ### Reference implementation Don't build the API calls and agent loop from scratch. Anthropic ships a working Docker reference implementation (the quickstart you pulled above) with the container, the three tools, and the agent loop already wired up. Start from that, then point it at your Tallyfy webhook. Tool names and model IDs change often, so copy the current ones from [Anthropic's docs](https://docs.anthropic.com). ### Security best practices **Key measures:** - Run Computer Use in a dedicated container or VM with minimal privileges. - Limit internet access to approved domains only. - Never give access to sensitive data or credentials. - Keep Claude isolated from production systems. - Require human confirmation for critical actions. - Enable audit logging. **Known risks:** - Prompt injection - Claude may follow on-screen instructions. - Code execution risks if it isn't properly sandboxed. - Information theft if it's given access to sensitive data. ### When to use it **Good fit:** - Desktop app automation (Excel, legacy software) - Data extraction from systems without APIs - Automated testing of desktop apps - Form filling across multiple apps - Low-risk, repetitive UI tasks **Poor fit:** - Real-time or time-critical operations - Tasks needing creative judgment - Social media content creation (restricted by Anthropic) - High-security environments without proper isolation **Tips for success:** - Start simple and well-defined - Set strong security boundaries - Monitor closely and keep humans in the loop - Test with low-risk data first ### Compared to alternatives **Advantages:** - Works with any desktop or web app - No app-specific APIs or integrations needed - Adapts when UIs change **Disadvantages:** - Slower than traditional RPA[^2] for simple tasks - Still experimental with some error-prone execution - Requires Docker and sandbox infrastructure - Higher latency than direct API calls **Alternatives to consider:** - Traditional RPA for stable, high-volume workflows - Direct API integrations when available - Browser-only automation tools for web tasks ### Getting started checklist - [ ] Identify repetitive desktop tasks worth automating - [ ] Document exact steps with screenshots - [ ] Set up Anthropic API access with credits - [ ] Install Docker and pull the reference implementation - [ ] Create a Tallyfy process with clear task instructions - [ ] Test with low-risk, non-sensitive data first - [ ] Set up security isolation and monitoring - [ ] Refine prompts based on success rates - [ ] Scale gradually with proven workflows [^1]: Webhooks let Tallyfy and your app message each other automatically the moment something happens. [^2]: Robotic process automation - older bots that follow fixed scripts and break when a screen changes. [^3]: OSWorld is a standard test of how well an AI agent completes real tasks across desktop and web apps. - **[Manus AI agents](https://tallyfy.com/products/pro/integrations/computer-ai-agents/vendors/manus/)**: Manus AI is a fully autonomous cloud-based agent that breaks down complex goals into subtasks handled by specialized sub-agents in parallel. It could integrate with Tallyfy for research-heavy workflow steps like market reports or competitive intelligence. ## Completing Tallyfy tasks with Manus AI agents Manus AI, built by Chinese startup Monica (also called Butterfly Effect AI), is a fully autonomous AI agent. It understands complex goals and delivers finished results without constant supervision. The company reports top scores on the GAIA benchmark. Because it handles web research, data analysis, planning, and content generation, Manus AI could pair well with Tallyfy 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.** Don't 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 coordinate Manus AI's multi-agent system for 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 does other work - **Multi-agent collaboration** - Specialized agents work in parallel on different parts of a task - **Complete deliverables** - Unlike simple automation, Manus produces finished reports and analysis ### How Manus AI works You give Manus a goal, and it runs asynchronously in the cloud to achieve it. Unlike traditional AI assistants that just respond to prompts, Manus operates on its own - making decisions, completing tasks, and producing finished results. * **Full autonomy:** It automates entire tasks from start to finish - planning, execution, and delivery. * **Multi-agent architecture:** Specialized sub-agents handle planning, information retrieval, web browsing, and code execution in parallel. * **Foundation models:** Manus uses existing LLMs including Claude 3.5 Sonnet and Claude 3.7 Sonnet from Anthropic, plus fine-tuned versions of Alibaba's Qwen models. * **Asynchronous cloud operation:** Assign a task and walk away. Come back later to find your results ready. * **Iterative agent loop:** The system cycles continuously: 1. **Analyze events:** Examines user requests and current task status 2. **Select tools and plan:** Chooses tools and refines plans using a Planner Module 3. **Execute commands:** Runs actions in a secure Linux sandbox 4. **Observe and iterate:** Evaluates results and repeats until done * **CodeAct approach:** Manus often writes and runs Python code on the fly to accomplish tasks. * **Tool usage:** Web browsers, shell commands, file management, and code execution (Python, JavaScript) are all available. * **Memory systems:** The agent tracks progress through event streams and file-based memory, even creating `todo.md` files to monitor itself. ### Current status and availability Manus AI is still in active development with expanding access: * **Access:** Register at manus.im - there's a free tier with one daily task (300 credits) * **Pricing:** $19/month (Basic) to $199/month (Pro) * **Geographic restrictions:** Works best outside mainland China, since the Western LLM models it relies on create access issues there * **Development status:** The platform keeps improving with updates like Manus 1.6 Max, which added better task completion and spreadsheet capabilities ### Performance claims and benchmarks * **GAIA benchmark:** Manus claims top performance across difficulty levels * **Task completion:** It can tackle multi-step tasks that need sustained attention and reasoning Independent verification of these benchmark claims is limited, so treat performance numbers with skepticism. ### Getting started with Manus AI (conceptual for Tallyfy) Manus AI access has expanded beyond private beta, but direct Tallyfy integration depends on API availability. ### How Tallyfy could integrate with Manus AI (example) Here's a research-heavy example: **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 a goal like: "Conduct market analysis for smart wearable devices targeting health-conscious consumers in North America. Research top 5 competitors in the $100-$300 range. Analyze trends, pricing strategies, and opportunities. Generate a structured report." 3. Manus AI's Planner Module breaks the work into subtasks: market research, competitor analysis, trend spotting, data synthesis, report writing. 4. Sub-agents browse the web, crunch data, and generate content in parallel. 5. After 30-60 minutes, Manus AI delivers the market analysis document. 6. Tallyfy receives the report, updates the task, and your team reviews it before moving on. ### Use cases **Business and marketing:** * Recruiting and interview optimization * Market analysis and competitive intelligence * SEO strategy development **Data analysis:** * Financial insights and investment analysis * Consumer analytics and sentiment tracking * Industry research **Content creation:** * Research report generation * Educational material development * Document generation and organization ### User feedback **What works well:** * Deep analysis that exceeds expectations * Successful completion of multi-step tasks * Time savings on research-heavy work **Common complaints:** * Tasks take 30 minutes to over an hour (OpenAI Operator is much faster) * Frequent crashes - beta software shows * Research often comes back without citations * Complex tasks requiring sustained reasoning often fail * Servers get overloaded during busy times * Performance varies wildly across task types ### Benefits * **Autonomous task execution:** Hand off research and analysis tasks to an AI that actually finishes them. * **Handles broad goals:** Give it a high-level objective. It figures out the steps. * **End-to-end completion:** From initial research to final deliverable - Manus handles the whole workflow. * **Asynchronous operation:** Your team focuses on strategy while Manus works in the background. * **Multi-modal capabilities:** Text, images, and data from various sources - it processes them all. ### Potential considerations * **Beta status:** You can't properly test it yet. Planning an integration around it is risky. * **Performance variability:** Complex tasks work sometimes and fail other times. * **Verification challenges:** Benchmark scores can't be verified independently due to access restrictions. * **Technical dependencies:** It's built on Claude and Qwen models - not their own. That's a dependency risk. * **Cost:** Paid plans range from $19-$199/month, which may not justify routine tasks. * **Reliability:** Beta users report crashes and failures that need human intervention. * **Task scoping:** You need to be precise but not too prescriptive. Finding that balance takes practice. Tallyfy and Manus AI could eventually work together for complex cognitive tasks, but the platform needs time to mature before it's stable enough for production integration. - **[OpenAI agent capabilities](https://tallyfy.com/products/pro/integrations/computer-ai-agents/vendors/openai-chatgpt-agent/)**: OpenAI's agent tools including the Responses API, Agents SDK, and Computer Use model connect with Tallyfy to automate web interactions like form filling and data extraction. Tallyfy provides the structured workflow layer with audit trails and error routing to humans while agents handle simple repetitive browser tasks. ## Using OpenAI agent capabilities with Tallyfy :::note[Information currency] OpenAI's agent features change often. Operator (launched January 2025) was deprecated by August 2025 and replaced by "ChatGPT agent" mode. Always check OpenAI's official docs for the latest capabilities and pricing. ::: OpenAI offers agent capabilities through three main tools: the Responses API, Agents SDK, and Computer Use (CUA) model. These connect with Tallyfy to automate web interactions, document processing, and data extraction. The CUA model now runs on o3 reasoning instead of the original GPT-4o. Its scores on the standard agent benchmarks are still modest, which is a good reminder not to lean on agents for anything complex yet (the numbers are below). These capabilities are available through "ChatGPT agent" mode. :::warning[Important guidance for AI agent tasks] Your step-by-step instructions for the AI agent go into the Tallyfy [task](/products/pro/tracking-and-tasks/tasks/) description. **Start with short, easy tasks that are mundane and tedious.** Don't ask an AI agent to handle large, decision-heavy jobs - they're prone to unpredictable behavior, hallucination, and costs can spiral fast. ::: ### How OpenAI agents work with Tallyfy Tallyfy triggers tasks, provides structured inputs through form fields, and captures outputs. You connect Tallyfy processes to OpenAI's agent tools with webhooks[^1] or API calls. [Diagram removed for brevity] **What to notice:** - **Multiple tools** - agents pick between computer use, web search, and file search based on what the task needs. - **Structured data flow** - Tallyfy sends inputs via form fields and captures agent outputs for downstream tasks. - **Error handling** - failed tasks route to human review through Tallyfy's conditional logic. ### OpenAI agent capabilities **Responses API** - combines chat with multi-tool support, so agents can use web search, file search, and computer use in a single API call. **Agents SDK** - open-source toolkit for single-agent and multi-agent workflows. Works with OpenAI models and competitors like Anthropic and Google. **Computer Use (CUA)** - browser automation using o3 reasoning. Takes screenshots, finds UI elements, and simulates mouse/keyboard actions. Available through ChatGPT agent mode. **Web search** - uses GPT-4o search with cited sources. **File search** - retrieves documents from large sets with metadata filtering. ### Connecting with Tallyfy workflows **Trackable execution** - every agent action runs inside a Tallyfy process with a full audit trail. **Error recovery** - when agents hit issues, Tallyfy's conditional logic routes tasks to humans. **Start small** - begin with simple tasks like form filling or data extraction. Watch the results, and don't expand the scope until they're working reliably. **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." ### CUA model details **Visual perception** - captures screenshots and identifies buttons, text fields, and links. **Action execution** - simulates mouse clicks and keyboard input on websites. **Safety controls** - pauses for user approval before sensitive actions like payments or credential entry. Includes fine-tuning to resist prompt injection. **Performance benchmarks**[^2] (original CUA model): - OSWorld: 38.1% (real-world computer tasks). - WebArena: 58.1% (web browsing tasks). **Works best for**: form filling, restaurant reservations, simple information gathering, and pulling documents from web portals. **Where it struggles**: complex interfaces, multi-page workflows needing sustained context, and sites with anti-bot measures. ### Current availability **ChatGPT agent mode** - available to Plus, Pro, and Enterprise subscribers. Select "agent mode" from the ChatGPT composer dropdown. **API access** - available through the Responses API and Agents SDK. Pricing and availability change frequently. See [OpenAI's pricing page](https://openai.com/pricing) for current details. ### Integration approach ### Example: restaurant reservation **Scenario** - automate restaurant reservations for client meetings. **Tallyfy task setup**: - Task description: "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 fires when task is assigned **What the agent does**: 1. Receives structured data from Tallyfy webhook 2. Goes to the booking site 3. Fills the reservation form 4. Captures the confirmation number 5. Returns the result to Tallyfy **Result handling**: - Success: confirmation number stored in a form field, next task triggered - Failure: task reassigned to a human with error details - Partial completion: flagged for manual review ### Integration options **Responses API** - send task data directly to OpenAI's API. The agent picks the right tools (web search, computer use, file search) to finish the job. **Agents SDK** - build custom orchestration with the open-source SDK. Supports multi-agent workflows and mixed model usage. **MCP server** - expose Tallyfy operations through a Model Context Protocol server. Agents interact with Tallyfy using natural language. **Webhook architecture** - use message queues between Tallyfy and OpenAI for high-volume automation with retry logic. ### Use case examples **Invoice data extraction**: - Agent goes to supplier portal, downloads invoices - Extracts invoice number, amount, and date - Returns structured data to Tallyfy - Human reviews before accounting entry **Customer onboarding**: - Sending workspace invites and setting up shared folders - Scheduling kickoff meetings - Generating welcome emails - Human handles contract review **Competitive research**: - Visits competitor websites and captures pricing info - Compares with previous data - Generates a summary report for team review ### Writing good task instructions Be specific. Include exact URLs, button names, field labels, and expected outputs. Good: "Go 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 and enable user approval for sensitive actions. **Monitoring** - track success rates by task type and adjust instructions based on failure patterns. ### Troubleshooting **Task fails repeatedly**: - Instructions too vague - add button names, URLs, exact text - Site has anti-bot measures - consider manual fallback - Dynamic content loading - agent may need explicit wait instructions **Integration not triggering**: - Verify webhook URL is accessible - Check authentication tokens - Confirm the Tallyfy process is published and active **Partial completion**: - Route partially completed tasks to humans via conditional logic - Add verification steps after agent tasks - Track patterns to refine instructions ### Limitations - Performance on complex tasks is low (the original CUA model scored well under half on the standard agent benchmarks) - Processing takes several minutes per task - Geographic availability is limited - Experimental technology - expect changes and occasional failures - Not suitable for tasks requiring judgment calls **Tips for success**: start with simple, high-volume tasks. Always keep a human fallback for critical processes. Test before production. Monitor success rates and keep instructions short and specific. [^1]: Webhooks let Tallyfy and OpenAI's tools message each other automatically the moment something happens. [^2]: OSWorld and WebArena are standard tests of how well an AI agent finishes real desktop and web tasks. - **[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 run web workflows without brittle scripts. It integrates with Tallyfy through webhooks using a three-agent architecture that adapts when websites change. :::note[Information currency] Browser automation tools change fast - check Skyvern's official docs at docs.skyvern.com for current features and pricing. ::: ## Browser automation with Skyvern Skyvern is an AI agent that uses a web browser the way a person would. It can log into sites, fill out forms, download files, and pull data back, all on its own. Because it actually looks at the page, it keeps working even when a website's layout changes. That's the big difference from older automation that breaks the moment a button moves. Under the hood, Skyvern uses large language models (LLMs[^1]) and computer vision, so it adapts in real time instead of following a fixed RPA[^2] script. It's open source (under the AGPL-3.0 license) and scores well on the WebVoyager benchmark for web agents. :::warning[Important guidance for AI agent tasks] Your step-by-step instructions for the AI agent go into the Tallyfy [task](/products/pro/tracking-and-tasks/tasks/) description. **Start with short, easy tasks that are mundane and tedious.** Don't ask an AI agent to handle huge, decision-driven jobs - they're prone to unpredictable behavior, hallucination, and costs can spiral quickly. ::: ### Integration with Tallyfy You can connect Skyvern to Tallyfy through webhooks[^3] or middleware platforms (Zapier, Make, n8n). The flow works like this: Tallyfy triggers the automation, Skyvern runs the browser workflow, and structured data comes back to Tallyfy. **What you get:** - **Three-agent setup** - 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 with full source access - **Cloud** - Managed service at app.skyvern.com with anti-bot measures, proxies, and CAPTCHA solving **Technical foundation:** - Multiple LLM providers: OpenAI, Anthropic, Azure OpenAI, AWS Bedrock, Ollama, OpenRouter, Gemini, Novita AI - Python 3.11-3.13 compatibility - Playwright for browser automation - Real-time visual parsing **Advanced features:** - CAPTCHA solving and 2FA (QR codes, email, SMS) - Proxy networks for geo-targeting - Livestream browser viewport for debugging - File downloads and uploads - Credit card form filling **Pricing:** - Cloud: Pay-per-step model (check current rates at skyvern.com) - Free tier with starter credit - Self-hosted: Free (you cover infrastructure and LLM API costs) ### Multi-agent architecture Skyvern splits work across three core agents: - **Planner** - Sets goals, tracks progress, breaks tasks into sub-goals - **Actor** - Executes browser actions for specific goals and reports status - **Validator** - Checks if goals succeeded, triggers retries when they don't These are backed by specialized sub-agents: - **Interactable Element Agent** - Identifies buttons, forms, and links in HTML - **Navigation Agent** - Plans action sequences to reach goals - **Data Extraction Agent** - Structures webpage data into JSON or CSV - **Password Agent** - Handles logins with password manager integration - **2FA Agent** - Manages authentication prompts - **Auto-complete Agent** - Handles form fields like address lookups ### Getting started ### Real-world use cases Skyvern's documentation highlights these production scenarios: **Invoice management** - Log into vendor portals, download statements, rename and organize files automatically. **Job applications** - Apply across multiple platforms, fill forms with candidate info, upload resumes. **Government compliance** - Submit forms to state and federal portals, handle multi-step 2FA flows, upload documents. **E-commerce** - Purchase from hundreds of sites, extract competitor pricing, post listings across platforms. **IT operations** - Employee onboarding/offboarding, system access provisioning, credential management. ### What sets Skyvern apart **Resilient to website changes** - Traditional RPA breaks when sites redesign. Skyvern uses visual understanding to adapt - no XPath selectors to maintain. **Open source** - Self-host and customize without vendor lock-in under the AGPL-3.0 license. **Handles web complexity** - CAPTCHA solving, 2FA, proxy networks, and credit card processing all work out of the box. **High throughput** - The API-driven design supports thousands of parallel automation tasks. ### Important considerations **Prompt quality matters** - Vague instructions lead to failed tasks. Write clear, specific prompts. **Self-hosting needs resources** - Browser automation with LLMs eats CPU and RAM. Budget for infrastructure costs on top of 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** - Even with anti-bot measures, aggressive automation can trigger rate limits. The cloud version includes proxy networks to help. **Task complexity** - Break multi-step workflows into smaller pieces. Test incrementally to find failure points early. [^1]: A large language model, the kind of AI that understands and writes text and, here, reads a web page. [^2]: Robotic process automation - older bots that follow fixed scripts and break when a screen changes. [^3]: Webhooks let Tallyfy and Skyvern message each other automatically the moment something happens, with no manual checking. - **[Twin.so AI agents](https://tallyfy.com/products/pro/integrations/computer-ai-agents/vendors/twin/)**: Twin.so builds AI agents that automate browser-based tasks like invoice retrieval at scale. Through enterprise partnerships, they can integrate with Tallyfy to handle repetitive web portal work like document downloads and data extraction without traditional APIs. :::note[Information currency] Twin.so works through direct enterprise partnerships, not self-service. Contact them for current pricing and capabilities. ::: ## Using Twin.so AI agents with Tallyfy Twin.so builds AI agents that control web browsers to automate tasks without needing an API. Their agents click buttons and fill forms just like a person would. Twin Labs (founded 2024) proved this works at scale. Their Invoice Operator serves 500,000+ European SMBs 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.** Don't 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 Here's a conceptual pattern where Tallyfy coordinates browser automation to pull documents from web portals. [Diagram removed for brevity] **What to notice:** - **Credential security** - Login info is stored separately from task descriptions - **Sequential execution** - Each step runs in order: site access, login, then data extraction - **Result delivery** - Extracted data or documents go back to Tallyfy so the workflow can continue ### What Twin.so offers Twin.so provides AI agents for browser-based automation. Based on their public information: **Core capabilities:** - **Browser control** - Agents open websites and interact with web apps - **Natural language goals** - Give a starting URL and a 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** - Vault system for storing website login credentials securely - **Enterprise infrastructure** - Browser infrastructure built for scale **Technology foundation:** - Remote Chromium browser sessions - AI models including OpenAI's CUA technology - Adapts to website changes (unlike traditional RPA scripts) - Twin Model action planning system for task processing Twin.so says they've improved speed, cost, and accuracy across three generations of their technology. ### Real-world deployment - Invoice Operator Twin.so's first major product is the Invoice Operator, built 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 This proves browser automation can handle production-scale, repetitive document retrieval. ### Potential integration with Tallyfy Twin.so focuses on enterprise partnerships, not self-service. Connecting 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 a webhook when assigned 2. Webhook calls Twin.so API with the task goal 3. Twin.so agent goes to the provider's billing portal 4. Agent logs in using vaulted credentials 5. Agent finds and downloads the specified invoice 6. Twin.so returns the invoice file and metadata 7. Tallyfy receives results and updates the task This same pattern works for other document retrieval and web-based data extraction scenarios. ### Use cases for browser automation Pairing Tallyfy's workflow management with browser automation could handle: - **Invoice collection** - Retrieve invoices from multiple vendor portals automatically - **Supplier monitoring** - Check order status and delivery tracking across supplier websites - **Data extraction** - Pull customer info from web-based systems that don't have APIs - **Compliance documentation** - Download required documents from regulatory portals - **Financial aggregation** - Collect account info from multiple banking websites - **E-commerce operations** - Monitor inventory, pricing, and listings across platforms ### Important considerations **Enterprise partnership model:** - Twin.so focuses on enterprise customers with custom implementations - No self-service signup or public pricing - Expect to work directly with their team for any integration **Integration requirements:** - Custom development needed to connect with Tallyfy - 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 **Geographic focus:** - Most deployments are currently in Europe (via Qonto partnership) - Check with Twin.so about availability in other regions ### 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 lets you create tasks from emails, start workflows, and manage your task list. You can also link email threads to existing tasks without leaving your inbox. ## Using the Tallyfy Gmail add-on The Gmail add-on lets you create tasks, start processes, and view your task list - right from your inbox. No tab switching needed. ### What you need - A Google Workspace or standard Gmail account - An active Tallyfy account - Permission from your Google Workspace admin to install add-ons (for work accounts) ### Key features - **Create Task** - turn any email into a Tallyfy task with the subject and body pre-filled - **My Tasks** - view, edit, and complete your assigned tasks without leaving Gmail - **Start Process** - pick a template and launch a workflow from any email - **Link Email to Task** - attach a Gmail thread to an existing Tallyfy task as a comment ### How to install it :::note[Admins installing for everyone] Google Workspace admins can install the add-on for everyone via the Admin Console (Apps > Marketplace Apps). ::: ### Using the add-on in Gmail Click the Tallyfy icon in Gmail's right sidebar. Sign in once, then you'll see the dashboard. The dashboard shows these buttons: **Create Task**, **My Tasks**, **Start Process**, **Link Email to Task**, and **Settings**. ![Tallyfy Gmail add-on in G Suite Marketplace](https://screenshots.tallyfy.com/tallyfy/pro/gmail-addon-marketplace-listing.png) ### Creating a task from an email ### Starting a process from an email Templates on a Docs plan won't appear here - you need a Basic or Pro plan to start processes. ### Checking your tasks ### Linking an email to a task This lets you post a Gmail thread as a formatted comment on any existing task. ### Troubleshooting | Problem | Fix | |-------------------------|------------------------------------------------------| | Tallyfy icon missing | Refresh Gmail and clear your browser cache | | Can't sign in | Sign out of the add-on completely, then sign back in | | Can't create tasks | Check your Tallyfy permissions - Light users have limits | | Add-on is slow | Try refreshing - it's usually a connection issue | ### Where it works The add-on works on desktop Gmail and the mobile Gmail app. Desktop gives the fullest experience. - **[Set up custom SMTP sending](https://tallyfy.com/products/pro/integrations/email/how-to-set-up-custom-smtp-in-tallyfy/)**: Route all Tallyfy notification emails through your own SMTP server so messages come from your organization's domain. You get full control over deliverability and sender reputation, and setup only requires a host, port, and credentials. ## Why use custom SMTP? Custom SMTP lets every workflow email come from your domain instead of Tallyfy's. Your SPF, DKIM, and DMARC records stay intact, deliverability improves, and recipients see your brand - not ours. Other benefits: - **Server-level tracking** - access your own logs for all outbound Tallyfy emails - **Security compliance** - email traffic stays within your existing infrastructure - **Consistent reputation** - your domain's sender score applies to workflow notifications :::caution[Email reply limitation] Custom SMTP disables reply-to-comment. When someone replies to a task notification, the response goes to your inbox - it won't appear as a comment in Tallyfy. ::: :::note[Single account only] Tallyfy uses one central email account (e.g. `tallyfy@company.com`) for all outgoing mail. Individual user accounts aren't supported for SMTP sending. ::: ### What you'll need | Parameter | Example | |-----------|---------| | SMTP Server Host | smtp.company.com | | Port | 587 | | Username (email format) | tallyfy@company.com | | Password | Your SMTP password | | From Email (optional) | workflows@company.com | | From Name (optional) | Company Workflows | Tallyfy uses TLS encryption automatically - there's no encryption dropdown to configure. ### Configuration steps If the connection test fails, you'll see an error message with details. Fix the issue and try again - nothing gets saved until the test passes. ### Testing with external tools Before going live, you can verify your SMTP server independently using these third-party tools: - [Microsoft Remote Connectivity Analyzer](https://testconnectivity.microsoft.com/tests/OutboundSMTP/input/) - thorough SMTP connectivity check ![Microsoft Remote Connectivity Analyzer for SMTP testing](https://screenshots.tallyfy.com/tallyfy/pro/smtp-microsoft-connectivity-analyzer.png) - [Wormly SMTP Tester](https://www.wormly.com/test-smtp-server/) - quick server responsiveness check ![Wormly SMTP server test tool](https://screenshots.tallyfy.com/tallyfy/pro/smtp-wormly-test-tool.png) - [MXToolbox SuperTool](https://mxtoolbox.com/SuperTool.aspx/) - DNS records, blacklist status, and infrastructure health ![MXToolbox SMTP diagnostic test results](https://screenshots.tallyfy.com/tallyfy/pro/smtp-mxtoolbox-test-results.png) - [GMass SMTP Tester](https://www.gmass.co/smtp-test/) - credential and authentication testing ![GMass SMTP Test Tool interface](https://screenshots.tallyfy.com/tallyfy/pro/smtp-gmass-test-tool.png) :::caution[External tools] These are third-party services. Consider using temporary test credentials if you're concerned about sharing SMTP passwords with external sites. ::: ### Verifying it works end-to-end ### Troubleshooting | Issue | Likely cause | Fix | |-------|-------------|-----| | Connection timeout | Firewall blocking port 587 | Open outbound SMTP port | | Authentication failure | Wrong credentials | Double-check username (must be email format) and password | | TLS errors | Server doesn't support TLS | Confirm your server supports TLS on the specified port | | Rate limiting | Too many connections | Raise server limits or reduce email volume | | DNS resolution failure | Bad hostname | Verify the SMTP host address resolves correctly | | Rejected messages | Sender mismatch | Ensure "From" address matches an authorized domain | #### If you're still stuck **Network**: Your firewall must allow outbound connections from Tallyfy's servers to your SMTP host on port 587. Test with telnet or openssl. **Authentication**: Some mail servers require app-specific passwords when MFA is enabled. Check whether your server accepts the authentication method Tallyfy uses. **DNS and email security**: Your SPF record must include your SMTP server's IP. If you use DKIM and DMARC, make sure they're configured correctly for the sending domain. :::tip[Best practice] After setup, send test emails to Gmail, Outlook, and Yahoo. You'll catch deliverability issues before your team does. ::: - **[Connect your email](https://tallyfy.com/products/pro/integrations/email/connect-your-email/)**: Connect Your Email lets each user send Tallyfy workflow notifications from their personal Gmail or Outlook account via OAuth. Recipients see emails from a real person instead of a system address, improving deliverability and response rates. ## What is Connect Your Email? **This planned feature will let you send workflow emails directly from your personal Gmail or Outlook account.** Instead of all emails coming from Tallyfy's servers, each user will authorize Tallyfy to send on their behalf - so recipients see emails from you@yourcompany.com, not a system address. When coworkers get a task notification from *you* rather than an automated system, they're more likely to open it, trust it, and act on it. Your IT department also benefits - emails stay within your company's existing security and compliance setup. ### How is this different from custom SMTP? The 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 good for branding - emails come from yourcompany.com. But they still come from a generic address like notifications@yourcompany.com. Connect Your Email is 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" Custom SMTP is like a company mailroom handling all outgoing mail. Connect Your Email is like sending the letter yourself, with your signature. ### Why connect your personal email account? **Deliverability improves when emails come from real accounts.** Your email address has years of reputation - people have you in their contacts, they've replied to you before, their email clients recognize you. That trust transfers to your workflow notifications. Beyond getting past spam filters: - **Higher response rates** - people respond to people, not systems - **Context stays intact** - replies go to your actual inbox - **Stronger audit trails** - every sent email appears in your Sent folder - **Simpler compliance** - your company's existing email retention policies apply automatically ### How will the connection process work? You'll click "Connect Email" in your Tallyfy settings, sign in with your email provider (Google or Microsoft), and grant permission to send on your behalf. No passwords are shared - it's handled through OAuth tokens you can revoke anytime. **For Google Workspace/Gmail users:** 1. Click Connect in Tallyfy settings 2. Sign in to your Google account 3. Review the permissions (only email sending is requested) 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. ::: ### What permissions will Tallyfy request? **Only the minimum permission needed: sending email.** Tallyfy won't read your inbox, access your contacts, or modify your settings. One permission only - sending emails as you. - **Google**: `gmail.send` scope only (not `gmail.readonly` or `gmail.modify`) - **Microsoft**: `Mail.Send` permission only (not `Mail.Read` or `Mail.ReadWrite`) Many email integrations request broad access to your entire mailbox. Tallyfy doesn't. You're granting permission to send specific workflow emails, nothing more. ### Will IT departments need to approve this? It depends on your organization's security settings. **Organizations with open policies** (most common): - Users connect immediately - No IT involvement needed **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 Tallyfy will provide your IT team with OAuth application details, security documentation, exact scopes requested, and compliance certifications. ### How will this work with multiple email accounts? Each Tallyfy user connects one primary email account. If you have multiple addresses, you choose which one to use for workflow notifications. You can switch anytime - disconnect the current one and connect a different one. ### What about email threading and conversations? **Workflow emails will thread properly with existing conversations.** Tallyfy includes the proper headers to maintain email threads. Recipients can reply directly to you, and those replies appear in your regular inbox. 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? This feature is in development. 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/)**: Tallyfy's planned Google Workspace integration sends workflow emails from your own Gmail address using OAuth 2.0 with only the `gmail.send` permission. It works with all Google security features and stores nothing beyond an encrypted refresh token and your email address. ## 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 from your email address.** It'll use Google's OAuth 2.0 with only the `gmail.send` permission - the minimum needed to send emails on your behalf without accessing your inbox or contacts. Google classifies email permissions into three tiers. The `gmail.send` scope is "Sensitive" (not "Restricted"), so Tallyfy can offer this integration without the expensive annual security audits that full email access requires. Personalized sending, no 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 handled before launch - nothing you need to do. What this means for you: - **No security assessment required**: No CASA audits needed since we don't read your email - **Standard verification only**: Takes 2-4 weeks, not months - **Faster approval**: Google reviews send-only apps quicker The verification confirms: - Tallyfy's identity and privacy policy - The app name and logo - Security practices and consent screens :::note[Why this matters] Many email integrations request the `https://mail.google.com/` scope, which requires expensive annual security assessments. By limiting to just `gmail.send`, Tallyfy keeps costs down while maintaining full security. ::: ### Will users see an "unverified app" warning? **No.** After verification, you'll see a standard Google consent screen showing Tallyfy's verified publisher badge, the exact permission you're granting (send email only), and how to revoke access later. Beta testers might see an "unverified app" screen during development, but that disappears after Google approves the application. ### What about Google Workspace admin controls? **Your Google Workspace admin controls whether users can connect third-party apps.** **Scenario 1: Open access (default)** - Admin has "Allow users to access any third-party apps" enabled - You can connect Tallyfy immediately - no admin action needed **Scenario 2: Restricted access** - Admin has blocked unconfigured third-party apps - Admin must add Tallyfy to the allowed list using the OAuth client ID we'll provide - Takes about 5 minutes to configure **Scenario 3: Highly restricted** - Organization blocks all third-party API access - Requires a policy exception - we'll provide security documentation for review ### How do IT admins approve Tallyfy? We'll provide admins with a setup guide including our OAuth client ID, screenshots, security compliance documentation, and a direct support contact. ### What if my organization uses IP restrictions? IP restrictions won't affect this integration. Emails sent through your account originate from Google's servers, not Tallyfy's. The API calls come from Tallyfy's servers, which you can whitelist if needed - typically just 3-5 IP addresses that rarely change. ### How does this work with Google's "Less Secure Apps" policy? **It doesn't use "Less Secure Apps" at all.** Tallyfy uses OAuth 2.0, which Google actively recommends. Google has already phased out less secure app access, but OAuth connections continue working indefinitely. - **Less Secure Apps**: Used your password directly (deprecated) - **OAuth 2.0**: Uses revocable tokens without password access (recommended) ### What about sending limits and quotas? **Your existing Gmail sending limits apply when Tallyfy sends on your behalf.** Google enforces these to prevent spam: | Account type | Daily limit | Recipients per message | |---|---|---| | Google Workspace | 2,000 emails | 500 | | Free Gmail | 500 emails | 500 | Workflow notifications rarely hit these limits. 50 task notifications per day is just 2.5% of a Workspace quota. ### Will emails appear in my Sent folder? **Yes.** Every email Tallyfy sends shows up in your Gmail Sent folder, creating a full audit trail. You can search, forward, or reply to any workflow email. Your existing backup systems and retention policies apply to these messages too. ### How do I revoke access? Three options: **From Tallyfy** - Go to **Settings** > **Email Integration** and click "Disconnect Google Account." **From Google** - Visit myaccount.google.com/permissions, find Tallyfy, and click "Remove Access." **Admin removal** - In Google Admin Console > Security > API controls, find Tallyfy and remove for specific users or the entire organization. Revocation takes effect immediately. Tallyfy can't send from your account anymore, but emails already sent stay in your Sent folder. ### What data does Tallyfy store? **Only the OAuth refresh token - not your emails or password.** | Stored | Never stored | |---|---| | OAuth refresh token (encrypted) | Your Google password | | Your email address (for display) | Email contents from your inbox | | Token expiration time | Contacts or calendar data | | Last successful send timestamp | Any other Google data | The refresh token is encrypted at rest and can only request short-lived access tokens for sending emails. ### Google security feature compatibility The integration works with all 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 If Google detects unusual activity, it might temporarily block sending, require reauthorization, or send you a security alert. ### Troubleshooting common authorization issues **"This app is blocked"** - Your admin has blocked third-party apps. Ask them to add Tallyfy using the OAuth client ID. **"Requires admin approval"** - Forward the consent link to your IT team. One-time approval unlocks access for all users. **"Invalid scope" error** - Clear your 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 retry. Check daily sending limits. **"Token expired"** - Normal after 6 months of inactivity. Reconnect your account - takes about 30 seconds. - **[Microsoft Outlook email connection](https://tallyfy.com/products/pro/integrations/email/connect-your-email/outlook/)**: Tallyfy's planned Microsoft Outlook integration sends workflow emails from your Microsoft 365 or Outlook.com account using Graph API. It requires only the Mail.Send permission and respects your organization's conditional access policies. ## Send Tallyfy emails from your own Outlook address :::note[Planned feature] This isn't available yet. The details below describe how it'll work once it's released. ::: When it's ready, Tallyfy will send its workflow emails from your own Microsoft 365 or Outlook.com address, so the notifications come from you, not a generic Tallyfy address. Tallyfy will only get permission to send email as you. It won't read your inbox, your calendar, or your contacts. ### What you'll get - **Emails that come from you.** Notifications send from your real address, so they look right to the people who get them and land better in their inboxes. - **A copy in your Sent Items.** Every email Tallyfy sends shows up in your Outlook Sent Items, so it's searchable, backed up, and there for any records you need. Your normal replies, forwarding, and rules all still work. - **Your company's security, respected.** It follows whatever sign-in rules your company already has, so nothing is bypassed. ### Will it work for your account? At launch it works with Microsoft 365 (Business or Enterprise) and personal Outlook.com accounts. On-premises Exchange and government clouds will come in a later release. Whether you can connect it yourself depends on your company's Microsoft settings. In many companies you'll just connect your own account in about a minute. In others, an IT admin approves Tallyfy once and then everyone can connect. Your IT team can find the setup steps under [For your IT team](#for-your-it-team). ### Sending limits Microsoft caps how many emails an account can send per day, and those caps apply here. Workflow notifications rarely get close - sending 100 task notifications a day uses about 1% of a Business plan's daily limit. The exact numbers are under [For your IT team](#for-your-it-team). ### Is it secure? Yes. Tallyfy only ever gets permission to send email as you, never to read your mail. You authorize it for your own account and can take that access away anytime. It honors your company's sign-in rules, including a second sign-in step (multi-factor) if your security team requires it, and it renews its access quietly in the background so you don't have to keep signing in. The integration is built to be GDPR, SOC 2, and HIPAA compatible. The full security and compliance detail is under [For your IT team](#for-your-it-team). ## For your IT team *(Skip this unless you're setting up the technical side.)* This planned integration uses Microsoft Graph API with only the `Mail.Send` permission - enough to send as the user, without reading their inbox or calendar. Graph API replaces SMTP authentication (which Microsoft is phasing out). It uses OAuth tokens and respects your organization's security policies. ### App registration Tallyfy will register as a verified Azure AD application to establish trust with Microsoft's identity platform. The registration covers: - **Publisher verification** - confirms Tallyfy's identity via a Microsoft Partner account - **App manifest** - defines exactly which permissions we request - **Consent screen** - shows users what they're authorizing Microsoft's requirements for `Mail.Send`: - No security assessment needed - Standard verification takes 1-2 weeks - Publisher verification requires a valid Microsoft Partner ID - Domain ownership must be verified :::note[Avoiding restricted scopes] Tallyfy won't request `Mail.Read` or `Mail.ReadWrite`. Those restricted scopes require expensive annual security assessments. Sticking to `Mail.Send` keeps things simple and secure. ::: ### Delegated vs application permissions Tallyfy will use delegated permissions - each user authorizes sending on their behalf. This is safer than application permissions, which would let someone send as anyone in your organization. **Delegated (what Tallyfy uses)** - each user authorizes individually, sees what they're granting, and can revoke anytime. **Application (not used)** - requires org-wide admin consent, could send as any user without their knowledge. ### Admin consent requirements Whether you need admin approval depends on your Azure AD settings. | Scenario | What happens | |----------|-------------| | User consent allowed (most common) | You connect your account directly - no IT involvement | | Admin consent required for new apps | Admin approves once, then all users can connect | | All third-party apps blocked | Requires explicit admin approval and possible security review | Tallyfy will detect your organization's settings and guide you through the right flow. ### How IT admins pre-approve Tallyfy ### Conditional access policies Tallyfy will respect all your conditional access policies - MFA, trusted devices, location restrictions, session limits, and risk-based authentication. Your security team can require MFA for Tallyfy, limit access to corporate devices, or force re-authentication on a schedule. ### Email sending limits Microsoft 365 enforces daily sending limits that apply to Graph API sends. | Plan | Recipients per day | Recipients per message | Rate limit | |------|-------------------|----------------------|------------| | Microsoft 365 Business/Enterprise | 10,000 | 500 | 30 messages/minute | | Outlook.com (personal) | 300 | 100 | Lower rate limits | Workflow notifications rarely approach these limits. 100 task notifications daily uses about 1% of a Business plan quota. ### Exchange on-premises The initial release supports cloud-based Microsoft 365 and Outlook.com only. On-premises Exchange needs hybrid connectivity and special Graph API configuration. Future support may include Exchange Web Services (EWS) and hybrid modern authentication. ### Sent items visibility Every email sent through Graph API appears in your Sent Items folder. It's searchable in Outlook, subject to retention policies, included in backups, and available for legal discovery. Replies, forwarding, categories, and rules all work normally. ### Token refresh Microsoft access tokens expire after 1 hour, but Tallyfy handles refresh automatically. A refresh token (valid 90 days with activity) lets Tallyfy get new access tokens without your involvement. Each use extends the refresh token's life. You'll only need to re-authenticate if you revoke access, 90 days pass without sends, your organization's policies force it, or Microsoft detects a security concern. ### Security and compliance The planned integration works with enterprise security features: - **Data residency** - emails processed in your Microsoft 365 region - **Audit logging** - API calls logged in Azure AD with sign-in tracking - **Compliance** - GDPR, SOC 2, HIPAA compatible (with BAA) - **Zero Trust** - no standing permissions, just-in-time token access, least privilege Emails pass through Microsoft's full security stack - Defender for Office 365 (outbound scanning, DLP), Purview (retention, eDiscovery), and Azure AD Identity Protection (risk-based access). ### Troubleshooting common issues **"Need admin approval" message** - Your organization requires admin consent - Click "Request approval" to notify your admin **"AADSTS65001: User or admin has not consented"** - The app needs to be added to your tenant - Admin must grant consent first **"Invalid client" error** - Usually a browser cache issue - try incognito mode - Clear cookies for login.microsoftonline.com **"Token expired" after connection** - Normal if unused for 90+ days - Reconnect your account (takes about a minute) **"SendAs permission denied"** - You're trying to send from a shared mailbox - Only personal mailbox sending is supported initially ### Government cloud support GCC and GCC High support is planned for a later release. Government clouds need separate app registration, FedRAMP compliance, and different Graph API endpoints. GCC High / DoD adds ITAR requirements. ### Open api - **[Third-party application API access](https://tallyfy.com/products/pro/integrations/open-api/access-api-as-a-third-party-application-instead-of-a-user/)**: Third-party apps can access Tallyfy's API through OAuth 2.0 client credentials. Your app gets an application-level token using a client ID and secret, then exchanges it for user-specific tokens to act on behalf of individual users. ## How third-party apps access Tallyfy's API Your application can make Tallyfy API calls on behalf of users through the OAuth 2.0 client credentials flow[^1]. You'll get an app-level token first, then exchange it for user-specific tokens that let you act as individual users. ### When to use this pattern - Embed Tallyfy workflow features inside your own software - Automate user provisioning for clients or employees - Run process management actions without users logging into Tallyfy directly ### What you'll need - A paid Tallyfy Pro or Enterprise subscription - Client credentials (client ID and secret) from Tallyfy Support - Familiarity with OAuth 2.0 client credentials flow :::caution[Paid feature] Client credentials access is only available to paid organizations, not during free trials. Contact Tallyfy Support to get set up. ::: ## OAuth client credentials flow Here's the full authentication flow for third-party applications. [Diagram removed for brevity] **What to notice:** - Your app authenticates itself first to get an app-level token - Both user provisioning and user token generation need that app-level token. This creates a chain of trust - App tokens manage users. User tokens perform workflow actions. They're distinct on purpose. ### Step 1 - Get client credentials ### Step 2 - Get an application access token Send a POST request to get your app-level 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] App tokens last 7 days (604,800 seconds). Request a fresh token before the current one expires. There's no separate refresh endpoint. ::: ### Step 3 - Provision users Create users in your Tallyfy organization using the app token. ``` 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` - can create and manage processes - `light` - can only complete assigned tasks Both `first_name` and `last_name` are required (max 32 characters each). The `role` and `timezone` fields are optional. **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 tokens To act as a specific user, request a token for their email address. ``` 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 ``` No request body needed. The email goes in the URL path. The user must already exist in your organization. **Response:** ```json { "token_type": "Bearer", "expires_in": 7776000, "access_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..." } ``` :::note[User token validity] User tokens last 3 months (7,776,000 seconds). Build your refresh logic around this timeline. ::: ### Step 5 - Make API calls as that user Use the user-specific token for any Tallyfy API call. It works exactly as if the user made the request themselves. ``` 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 `X-Tallyfy-Client: APIClient` in every API call. Requests without it may not work correctly. ::: ### Security tips - Keep client credentials in encrypted storage or a secrets manager - Control which parts of your app can access user tokens - Confirm user emails belong to your organization before requesting tokens - Handle token expiration gracefully: refresh before they expire, not after ### Troubleshooting | Error | Cause | Fix | |-------|-------|-----| | 401 Unauthorized | Bad client credentials | Double-check your client ID and secret | | 403 Forbidden | Token doesn't match the organization | Verify the client is linked to the correct org | | 404 Not Found | User doesn't exist | Check the email and organization ID | | 422 Unprocessable | User not in your org | The email exists but isn't part of your organization | | 429 Too Many Requests | Rate limit hit | Wait the seconds given in the `Retry-After` header, then retry | Contact Tallyfy Support if you're stuck - include your error messages and the endpoint you're calling. [^1]: OAuth 2.0 is an industry-standard protocol for delegated authorization without sharing passwords - **[Custom fields](https://tallyfy.com/products/pro/integrations/open-api/custom-fields/)**: Tallyfy custom fields let your organization attach labeled key/value metadata to records like processes, tasks, members, guests, folders, tags, templates, steps, form fields, and kick-off fields. Admins define the keys, and the REST API reads and writes values with PUT, PATCH, and DELETE. ## Store your own metadata on Tallyfy records Custom fields let your organization tag Tallyfy records with your own labeled data. Think of a cost center on a process, a region on a guest, or a risk rating on a template. You define the labels once as an admin, then read and write their values through the REST API. :::note[Custom fields are not form fields] Tallyfy has two similarly named things, and they do different jobs. - **Custom fields** (this page) are metadata *about* a record. They sit on the process, task, member, guest, folder, tag, template, step, form field, or kick-off field itself. - **[Form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/)** (the API calls them `captures`) are the data people fill in *inside* a task or a kick-off form. Most other tools call their form inputs "custom fields", so when you migrate in, that data lands in Tallyfy form fields, not here. The [migration guide](/products/pro/tutorials/features/migrate-to-tallyfy/) shows how source data maps across. ::: ## What you can attach custom fields to Custom field values live on ten kinds of record. Each has its own endpoint under `/organizations/{org_id}`. | Record (app name) | Value endpoint | Single-key PATCH | |---|---|---| | Process | `/runs/{run_id}/custom-fields` | Yes | | Task | `/runs/{run_id}/tasks/{task_id}/custom-fields` | Yes | | Member | `/users/{user_id}/custom-fields` | Yes | | Guest | `/guests/{guest_code}/custom-fields` | Yes | | Folder | `/folders/{folder_id}/custom-fields` | Yes | | Tag | `/tags/{tag_id}/custom-fields` | Yes | | Template | `/checklists/{checklist_id}/custom-fields` | No | | Step | `/checklists/{checklist_id}/steps/{step_id}/custom-fields` | No | | Form field | `/checklists/{checklist_id}/steps/{step_id}/captures/{capture_id}/custom-fields` | No | | Kick-off field | `/checklists/{checklist_id}/preruns/{prerun_id}/custom-fields` | No | Template, step, form field, and kick-off field records sit on the template side. You save their values with a full PUT, and there's no single-key PATCH by design. A template freezes once processes launch from it, so a per-key patch would force a full copy of the template on every small edit. A full-replace PUT is the natural way to save the definition. ## Field types A key holds one of eleven field types: `text`, `textarea`, `number`, `boolean`, `date`, `email`, `url`, `radio`, `dropdown`, `multiselect`, `table`. The type decides how Tallyfy validates and stores the value. Choice types (`radio`, `dropdown`, `multiselect`) and `table` need their options or columns defined on the key. The schema for those lives in the live [API reference](https://go.tallyfy.com/api/). ## Keys and values There are two layers, and they carry different permissions. - **Keys** are the definitions: the name, the field type, which record type they apply to, and whether they're required. Only organization admins (and support staff masquerading as an admin) can create, edit, or delete keys. - **Values** are what each record holds for a given key. Who can set a value depends on the record: - **Task**: an org admin or the task's assignee. Value changes are also written to the task's history. - **Member**: the member themselves, or an admin. - **Guest**: any member can read guest values; only an admin can write them. - **Folder** and **tag**: any member can edit. Most record payloads already carry their values, as long as you're signed in as a member. When you fetch a task, process, template, step, form field, kick-off field, folder, or tag, the response includes a `custom_fields` object, so you don't need a separate call to read them. Values are visible only to members: a guest session, or a public (signed-out) view of a shared template or process, always sees `custom_fields` as `null`. Member and guest records are a further exception: their payloads don't embed the object at all, so read those values with the dedicated `GET .../custom-fields` call for the record. ### Required headers Every request needs these headers. Tallyfy rejects calls without `X-Tallyfy-Client`. ``` Authorization: Bearer YOUR_ACCESS_TOKEN Accept: application/json X-Tallyfy-Client: APIClient ``` Add `Content-Type: application/json` on any POST, PUT, or PATCH that sends a body. Replace `{org_id}` with your [Organization ID](/products/pro/miscellaneous/how-to-find-your-tallyfy-ids/). ## Define a key Admins create keys with a POST. This example defines a text key that applies to processes. ```bash curl -X POST "https://go.tallyfy.com/api/organizations/{org_id}/custom-field-keys" \ -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \ -H "Accept: application/json" \ -H "X-Tallyfy-Client: APIClient" \ -H "Content-Type: application/json" \ -d '{ "key": "cost_center", "applies_to": "process", "field_type": "text", "is_required": false, "is_active": true }' ``` Set `applies_to` to the record type the key belongs to. The accepted values, plus the schema for choice types and table columns, are in the live [API reference](https://go.tallyfy.com/api/). The `key`, `applies_to`, `field_type`, and `key_type` of a key can't change after creation. An update touches only settings like `is_required` and `is_active`. ## List keys ```bash curl "https://go.tallyfy.com/api/organizations/{org_id}/custom-field-keys?applies_to=process&is_active=true&per_page=50" \ -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \ -H "Accept: application/json" \ -H "X-Tallyfy-Client: APIClient" ``` Filter and sort the list with these query parameters: `applies_to`, `key_type`, `field_type`, `is_required`, `is_active`, `q` (text search), `sort_by`, `sort_direction`, and `per_page`. ## Set values A PUT replaces the whole set of values on a record. This example sets two values on a process. ```bash curl -X PUT "https://go.tallyfy.com/api/organizations/{org_id}/runs/{run_id}/custom-fields" \ -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \ -H "Accept: application/json" \ -H "X-Tallyfy-Client: APIClient" \ -H "Content-Type: application/json" \ -d '{ "custom_fields": { "cost_center": "CC-1042", "priority": "High" } }' ``` A few rules apply to PUT: - It's a full replace. Any org key you leave out is cleared. - Required org keys must be present, or the call fails with `422`. - System key values are left untouched (see [System keys](#system-keys) below). - An unknown key, or an attempt to write a system key, is rejected with `422`. - Sending `{"custom_fields": {}}` clears every optional org value on the record. If the record type has a required key, you have to include it, so a bare `{}` fails with `422`. ## Merge one value A PATCH sets a single value and leaves the rest alone. The key goes in the URL, and the body carries just its value. There's no required-key check, so it's the call to reach for when you want to change one value without re-sending everything. ```bash curl -X PATCH "https://go.tallyfy.com/api/organizations/{org_id}/runs/{run_id}/tasks/{task_id}/custom-fields/priority" \ -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \ -H "Accept: application/json" \ -H "X-Tallyfy-Client: APIClient" \ -H "Content-Type: application/json" \ -d '{ "value": "Low" }' ``` Template, step, form field, and kick-off field endpoints don't accept PATCH. Use PUT to save those. ## Remove one value A DELETE removes a single value from a record. The key goes in the URL, and the request has no body. ```bash curl -X DELETE "https://go.tallyfy.com/api/organizations/{org_id}/runs/{run_id}/custom-fields/priority" \ -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \ -H "Accept: application/json" \ -H "X-Tallyfy-Client: APIClient" ``` Deleting a system-managed key's value returns `403`. ## How values are inherited When a record is created, it can pick up values from its parent: - A new process inherits its template's custom field values. - A new task inherits its step's custom field values. Inheritance runs once, at creation time, and only forward. Changing a template's custom fields later does not reach back into processes that are already running. If a process or task already has its own value for a key, that value wins over the inherited one. ## System keys Some keys have a `key_type` of `system`. Tallyfy manages these itself for platform metadata. In this release they're seeded by Tallyfy only, there's no admin endpoint to create them, and the API never sets, edits, or deletes their values. You can still read them: they show up in the `custom_fields` object like any other value. A PUT preserves them, and a delete on a system key returns `403`. ## Filter tasks by a custom field The organization task list accepts two custom field filters, `custom_field_key` and `custom_field_value`. Pass both to return only tasks whose value for that key matches. ```bash curl "https://go.tallyfy.com/api/organizations/{org_id}/tasks?custom_field_key=priority&custom_field_value=High" \ -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \ -H "Accept: application/json" \ -H "X-Tallyfy-Client: APIClient" ``` This pairs with the other filters on the [list organization tasks](/products/pro/integrations/open-api/code-samples/tasks/list-org-tasks/) endpoint. - **[Sniff API calls using Chrome](https://tallyfy.com/products/pro/integrations/open-api/how-to-sniff-api-calls-using-chrome/)**: Chrome DevTools lets you inspect every API call Tallyfy makes. Filter network requests in the Fetch/XHR panel, then copy endpoints, headers, and JSON payloads to replicate those calls in your own integrations with cURL or Postman. ## Inspecting Tallyfy API calls with Chrome DevTools Tallyfy uses an API-first architecture, which means every action in the web app makes API calls you can inspect. By watching these calls in Chrome DevTools, you can figure out exactly how to replicate them for your own integrations. ### Before you start - Chrome browser (latest version recommended) - A Tallyfy account with the right permissions - Basic understanding of HTTP requests and JSON :::note[API documentation] Full API reference is available at [https://go.tallyfy.com/api/](https://go.tallyfy.com/api/) ::: ### Required API header When making direct API calls to Tallyfy, you must always include this header: ``` X-Tallyfy-Client: APIClient ``` :::caution[Header requirement] Requests without this header will be rejected. It's a security requirement. ::: ## Capturing API calls ### Setting up DevTools ### Reading request details #### Headers tab In the **Headers** tab, you'll find: - **General info**: The full request URL, HTTP method (GET, POST, PUT, DELETE), and status code (200 for success, 400 for client errors, etc.) - **Request headers**: Look for `Authorization: Bearer `, `X-Tallyfy-Client: APIClient`, and `Content-Type: application/json` - **Response headers**: Server metadata, rate limiting info, and caching directives #### Payload tab For POST, PUT, or PATCH requests, click the **Payload** tab to see what was sent: - **Form Data** shows URL-encoded parameters - **Request Payload** shows the JSON body - **View Source** shows the raw data exactly as sent To copy the payload: #### Response tab Check what came back from the server: - The **Response** tab shows raw data - The **Preview** tab shows formatted JSON Look at the data structure, success/error messages, pagination info, and timestamp formats. ![Chrome DevTools showing Tallyfy API request payload](https://screenshots.tallyfy.com/tallyfy/pro/api-chrome-devtools-sniff.png) ### Required headers for replicating calls | Header | Value | Purpose | |--------|-------|---------| | `Authorization` | `Bearer YOUR_TOKEN` | Authentication | | `X-Tallyfy-Client` | `APIClient` | Required identifier | | `Content-Type` | `application/json` | Request format | | `Accept` | `application/json` | Response format | ### Testing your captured calls To verify you've correctly captured a Tallyfy API call: #### Example cURL command Here's what a typical Tallyfy API call looks like in cURL - this one launches a process from a template: ```bash curl -X POST "https://go.tallyfy.com/api/organizations/{org_id}/runs" \ -H "Authorization: Bearer YOUR_TOKEN" \ -H "Content-Type: application/json" \ -H "X-Tallyfy-Client: APIClient" \ -H "Accept: application/json" \ -d '{ "checklist_id": "abc123", "name": "Test Process" }' ``` ### Useful DevTools features #### Exporting a request as cURL #### Throttling network speed You can simulate slow connections to test how your integration handles latency. Click the dropdown next to **Online** in the Network panel and pick a throttling preset. ### Troubleshooting #### No requests showing up - Make sure DevTools is open *before* you perform the action - Enable **Preserve log** in the Network tab - Disable cache and hard-refresh the page - Check you're looking at the correct browser tab #### Filter isn't showing results - Verify the filter text matches part of the API URL - Try clicking **Fetch/XHR** instead of using the text filter - Clear all filters to confirm requests exist at all #### Getting 401 authentication errors - Check that your Tallyfy session is still active - Verify the Bearer token hasn't expired - Make sure all required headers are included - Confirm your account has permission for the action #### CORS or preflight issues If you're making cross-origin requests from your own app: - Watch for `OPTIONS` preflight requests in DevTools - Check the response headers for allowed origins and methods ### Security reminders - **Never share your auth tokens** publicly or in screenshots - **Mask sensitive data** before sharing request details - **Tallyfy logs all API actions** in its audit trail - **[API integration guide](https://tallyfy.com/products/pro/integrations/open-api/how-to-integrate-with-tallyfy-using-api/)**: Tallyfy's REST API lets you connect workflow features to external systems using OAuth 2.0 authentication. Covers required headers, API terminology mapping, token management, and multi-organization setup. ## Integrating with the Tallyfy REST API Tallyfy's REST API lets you connect workflow features to your own applications and systems. :::note[API documentation] Full API reference at [https://go.tallyfy.com/api/](https://go.tallyfy.com/api/) ::: ## API terminology The Tallyfy API uses different names than what you'll see in the web app. Here's the mapping you'll need when reading API responses, building integrations, or browsing the [API reference](https://go.tallyfy.com/api/): | What users see in the app | API endpoint | Other names you might see in code or older docs | |---|---|---| | Template | `/checklists` | Blueprint, checklist | | Process | `/runs` | Run, workflow | | Step (inside a template) | `/steps` | Step | | Task (inside a running process) | `/tasks` | Task | | Task form field | `/form-fields` | Capture, form field | | Kick-off form field | `/preruns` | Prerun, KO form, kick-off form | | Comment or issue on a process | `/runs/{id}/comment`, `/runs/{id}/problem`, `/runs/{id}/resolved-threads` | Thread | | Comment or issue on a template | `/checklists/{id}/comment`, `/checklists/{id}/problem`, `/checklists/{id}/resolved-threads` | Thread | A template "becomes" a process when launched. A step "becomes" a task once the process is running. Form fields collect data inside tasks; kick-off form fields collect data before a process starts. These name differences are historical and only show up when reading API responses or older code. The Tallyfy app itself only uses the user-facing names (Template, Process, Task, etc.). ### Required headers Every API call must include these headers: ``` Authorization: Bearer YOUR_ACCESS_TOKEN X-Tallyfy-Client: APIClient Accept: application/json ``` **Important**: Tallyfy rejects requests without the `X-Tallyfy-Client` header. ### Authentication methods Tallyfy supports two authentication approaches: #### 1. User-based authentication For integrations acting on behalf of a specific Tallyfy user: This video shows how to get your access token: #### 2. Application-based authentication For third-party apps needing client credentials: 1. Contact Tallyfy Support describing your integration needs 2. You'll receive a **Client ID** and **Client Secret** 3. Implement the OAuth 2.0 flow to get and refresh access tokens ## OAuth authentication flow This diagram shows the full OAuth flow for both authentication methods. [Diagram removed for brevity] **What to notice:** - Steps 1-4 show initial authentication - use password grant for user context or client credentials for app-only access - Step 5 shows required headers for all API requests - both `Authorization` and `X-Tallyfy-Client` headers are mandatory - Steps 6-10 show token refresh when a 401 error occurs - your app should handle this retry automatically ### Token management #### Handling token invalidation Personal access tokens are invalidated when users log out. To reduce disruption: 1. **Automated systems**: Use application tokens (Enterprise plans) instead of personal tokens when possible 2. **User-based integrations**: - Let users know that logging out breaks automations - Add error handling to detect invalidated tokens - Provide clear steps for getting new tokens after logout 3. **Monitoring**: Log authentication failures to spot patterns early #### Token security - Store tokens with encryption at rest - Never expose tokens in client-side code or logs - Rotate tokens regularly for sensitive operations - Handle token expiration by refreshing automatically ### Working with multi-organization users Tallyfy users can belong to multiple organizations[^1]. This matters for API integrations: #### Organization context in API requests - A user's access token is tied to their current organization - API requests operate within that organization's context - Organization IDs are required in most API endpoint URLs (e.g., `/organizations/{org_id}/checklists`) #### Collecting organization IDs When building integrations: 1. Collect the organization ID during setup 2. Store it alongside user credentials in your app 3. Include it in your API request URLs #### Multiple organizations For users belonging to more than one organization: 1. Let users pick which organization to work with 2. Store multiple organization IDs if your app spans organizations 3. Permissions and data differ between organizations 4. You may need updated tokens when switching organizations :::tip[Organization switching] Users can switch organizations in the Tallyfy UI. Learn more in [Switch between organizations](/products/pro/settings/personal-settings/how-can-i-switch-between-organizations-in-tallyfy/). ::: ### Getting access tokens with password grant Getting 401 "Unauthenticated" errors despite having valid client credentials? You likely need the password grant flow. :::note[Grant type selection] The **client_credentials** grant type won't provide tokens that work for user-specific endpoints. For standard API endpoints requiring user context, you must use the **password** grant type. ::: 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=password& client_id=YOUR_CLIENT_ID& client_secret=YOUR_CLIENT_SECRET& username=YOUR_EMAIL& password=YOUR_PASSWORD ``` 2. You'll get a response with an access token: ```json { "token_type": "Bearer", "expires_in": 3600, "access_token": "eyJhbGci...", "refresh_token": "def50200..." } ``` 3. Use this token in the `Authorization` header: ``` Authorization: Bearer YOUR_ACCESS_TOKEN ``` :::caution[Security note] The password grant requires transmitting user credentials. Only use this in secure server-side environments where you control both the client app and user accounts. ::: ### Understanding grant types | Grant type | Purpose | Access context | Best for | |------------|---------|----------------|----------| | **client_credentials** | App-to-app authentication | Application context only | Backend services, system integrations | | **password** | User-based access via application | Full user context | Endpoints requiring user permissions | **Key distinction**: Most Tallyfy API endpoints require user context, so `password` grant is usually what you need. If you're getting 401 errors with a `client_credentials` token, switch to `password` grant. ### Token refresh Access tokens expire after 1 hour and need refreshing: 1. Store both the **access_token** and **refresh_token** when first obtained 2. When the access token expires, POST to the token endpoint with your refresh token 3. You'll receive a new access token (and sometimes a new refresh token) ![Tallyfy API OAuth token endpoint in Swagger](https://screenshots.tallyfy.com/tallyfy/pro/api-oauth-token-swagger.png) This video shows the token refresh process: ### Troubleshooting authentication #### 401 unauthenticated errors 1. **Token format**: Make sure your Authorization header is exactly: ``` Authorization: Bearer YOUR_ACCESS_TOKEN ``` There must be exactly one space between "Bearer" and your token. 2. **Token expiration**: Tokens expire after 1 hour. Refresh or request a new one. 3. **Invalid credentials**: Double-check your client ID, client secret, username, and password. 4. **Missing headers**: Every request needs the `X-Tallyfy-Client: APIClient` header. 5. **Wrong token endpoint**: Confirm you're hitting `https://go.tallyfy.com/api/oauth/token` with the correct `grant_type`. 6. **Logout invalidation**: Personal tokens are immediately invalidated on logout. If your automation stops working, check whether the user logged out. If problems persist, check the response body for specific error messages or contact Tallyfy Support with your full error response. #### CORS or preflight issues For cross-origin challenges: - Watch for CORS preflight (`OPTIONS`) requests - Check response headers for CORS permissions - Verify allowed origins and methods ### Preventing duplicate operations :::tip[Implement idempotency] External systems might send duplicate requests from network retries, user errors, or repeated webhook events. Implement [idempotency handling](/products/pro/integrations/handling-idempotency-in-webhooks-and-api/) to prevent unintended duplicate operations - especially 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-MM-DD HH:MM:SS | 2025-05-15 14:30:00 | | Response (from API) | ISO 8601 (Zulu time) | 2025-05-15T14:30:00.000Z | Make sure your code handles both formats correctly. ### Webhook integration For event-driven integrations, Tallyfy offers webhooks that don't require polling the API: - Configure webhooks at the process or step level - Get real-time notifications when specific events happen - Process the webhook payload to trigger actions in your systems For setup details, see the [webhooks setup guide](/products/pro/integrations/webhooks/how-to-set-up-webhooks-in-tallyfy/). [^1]: Organizations in Tallyfy are isolated tenants - each with its own templates, processes, members, and settings - **[Combining RPA systems and human operators](https://tallyfy.com/products/pro/integrations/open-api/how-does-tallyfy-combine-rpa-systems-and-human-operators/)**: Tallyfy coordinates RPA tools like UiPath and Blue Prism with human operators. It manages automated and manual tasks in one workflow through its API, with handoffs, exception handling, and full process visibility in one place. ## Connecting RPA bots with human workflows RPA tools like UiPath, Automation Anywhere, and Blue Prism handle repetitive, rule-based tasks well - but most real processes also need human judgment. Tallyfy bridges that gap by managing both automated and human tasks in one workflow through its API. :::note[API documentation] For integrating Tallyfy with RPA systems, refer to our [complete API documentation](https://go.tallyfy.com/api/) ::: ### Why it's hard without Tallyfy When RPA bots and people work in separate systems, you run into problems: - **Fragmented processes** - automated and manual steps live in different tools - **No unified visibility** - you can't see the full process status in one place - **Broken handoffs** - managing transitions between bots and humans is messy - **Unclear accountability** - nobody knows who's responsible for what ### How Tallyfy solves this Tallyfy acts as the coordination layer that: 1. **Manages the full process** - both automated and human tasks in a single workflow 2. **Shows everything in one view** - status of both RPA and human activities 3. **Handles handoffs** - transitions work between systems and people automatically 4. **Tracks responsibility** - clear accountability throughout the process ### How it works in practice A typical setup looks like this: - RPA bots execute automated tasks and call the Tallyfy API to report status - Tallyfy's API manages process flow, creates tasks, and routes assignments - Human operators complete tasks that need judgment or decisions - API calls keep everything in sync between all systems ### RPA and human task flow This diagram shows how RPA systems, Tallyfy's API, and human operators interact during process execution. [Diagram removed for brevity] **What to notice:** - **Automatic handoffs** - work transitions between RPA bots and human operators through Tallyfy's API - **Exception handling** - when RPA hits issues, Tallyfy escalates to human operators for resolution before resuming automation - **Full visibility** - the Tallyfy UI tracks every action from both automated and human activities in real-time ### Example: employee onboarding Here's how Tallyfy coordinates an employee onboarding process that mixes RPA and human tasks: - RPA handles structured tasks like system access provisioning - Human operators manage judgment-based activities like document review - Tallyfy tracks status across both automated and manual steps - The entire process stays visible in a single interface ### Why this matters This approach gives you: - **Faster processes** - automate what you can while keeping quality on human tasks - **Fewer errors** - bots handle repetitive work consistently - **Full visibility** - see everything across all activities in one place - **Easier adoption** - Tallyfy's interface is built for business teams, not just developers - **Flexibility** - change process flows without rebuilding integrations To learn more about 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). - **[OAuth authorization flow for third-party applications](https://tallyfy.com/products/pro/integrations/open-api/oauth-authorization-flow/)**: Tallyfy's OAuth 2.0 implicit grant flow lets third-party apps authenticate users by redirecting them to Tallyfy's login page and receiving a 6-month access token back in the URL fragment so the app never handles user credentials directly. ## OAuth implicit grant flow for third-party apps Tallyfy uses the OAuth 2.0 implicit grant[^1] flow for third-party application authentication. Your users log in directly on Tallyfy's domain, and an access token comes back in the URL fragment - your app never touches their credentials. ### Requirements - Paid Tallyfy Pro or Enterprise subscription - Client ID from Tallyfy (contact support) - A registered redirect URI for your application :::caution[Paid feature] The OAuth authorization flow is only available to paid organizations. Contact Tallyfy Support to get a Client ID for your application. ::: ### How the flow works Here's 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 log in directly with Tallyfy and receive an access token via URL fragment, which the third-party app extracts for Bearer-authenticated API requests. **What to notice:** - The access token is returned in the URL fragment (after `#`) - fragments aren't sent to servers, which adds a layer of protection - Authentication happens entirely on Tallyfy's domain, so your app never sees user credentials - You must include the `X-Tallyfy-Client` header in all API calls after authentication #### Step 1 - redirect users to Tallyfy's 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 and `YOUR_REDIRECT_URL` with your registered redirect URI. Users need a verified email to proceed - they'll see Tallyfy's login page where they authenticate with their own credentials. #### Step 2 - handle the redirect with the access token After successful authentication, Tallyfy redirects back to your redirect URI with the access token in the URL **fragment** (after `#`, not `?`): ``` 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 fragment using client-side JavaScript 2. Store it securely 3. Use it for subsequent API requests :::note[Token lifetime] Implicit grant tokens are valid for 6 months. Plan your token refresh strategy accordingly. ::: #### Step 3 - make API requests with the access token Include 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 `X-Tallyfy-Client: APIClient` in all API calls. Tallyfy rejects requests without this header. ::: ### 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=eyJhbGciOiJSUzI1NiIs...&token_type=Bearer&expires_in=15778800 ``` #### Handling multi-organization users A Tallyfy user can belong to multiple organizations. After authentication, the access token is tied to whichever organization the user is logged into. If your app needs to work across multiple Tallyfy organizations: 1. Store the organization context alongside the access token 2. Consider adding organization selection in your application 3. You may need separate authentication flows per organization ### Security best practices - Always use HTTPS for all OAuth-related communication - Store access tokens securely and encrypted at rest - Monitor token expiration and prompt re-authentication before tokens expire - Validate all redirect URIs against expected patterns ### Troubleshooting | Issue | Possible cause | Solution | |-------|----------------|----------| | Authorization fails | Invalid client ID | Verify your client ID with Tallyfy Support | | Redirect fails | Mismatched redirect URI | The redirect URI must match exactly what's registered | | Token doesn't work | Token expired or user email unverified | Check expiration and ensure the user has verified their email | | Organization context issues | User belongs to multiple organizations | Clarify organization context during authentication | If you run into issues with your OAuth implementation, contact Tallyfy Support with details about the error and your setup. [^1]: A simplified OAuth flow where the access token is returned directly in the redirect URL fragment - no intermediate authorization code exchange needed - **[API clients](https://tallyfy.com/products/pro/integrations/open-api/api-clients/)**: Tallyfy's REST API works with any HTTP client. Find guides for tools like Postman to visually test endpoints and explore authentication without writing code. Tallyfy's REST API works with any HTTP client. Here's how to get started with popular API testing tools. ## Available client guides - **[Postman](/products/pro/integrations/open-api/api-clients/postman/)** - Visual interface for testing Tallyfy API endpoints without writing code ## Why use an API client? API clients let you: - Test Tallyfy endpoints without writing code - Explore the API interactively - Generate code snippets in your preferred language - Share request collections with your team - Debug authentication and request issues The Postman guide covers Tallyfy-specific authentication setup, common operations, and real request examples you can run immediately. - **[API code samples](https://tallyfy.com/products/pro/integrations/open-api/code-samples/)**: Tallyfy's REST API code samples are organized by resource category with working examples in six programming languages. Every request requires a Bearer token along with Accept and X-Tallyfy-Client headers sent to the org-scoped base URL. Each category below has working code samples in JavaScript, Python, Java, Go, C++, and C# for the Tallyfy REST API. Pick a resource to get started. All examples assume you've got a **Personal Access Token** or valid OAuth token. The base URL is `https://go.tallyfy.com/api`, and every endpoint is org-scoped under `/organizations/{org_id}/...`. Here's what to include with every request: - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` - `Content-Type: application/json` (for POST/PUT requests that include a JSON body) ### Api clients - **[Getting started with Postman API testing](https://tallyfy.com/products/pro/integrations/open-api/api-clients/postman/)**: Test Tallyfy's REST API in Postman without writing code. Authenticate with the password grant type, then explore endpoints for templates (checklists), processes (runs), and tasks across your organization. Set up authentication with your Tallyfy credentials in Postman, then start testing endpoints for templates, processes, and tasks. No code required. ## Why use Postman with Tallyfy? Postman lets you test Tallyfy's API without writing code. You can: - Launch processes from templates - Complete tasks and update statuses - Export workflow data - Test integrations before building them Think of it as a playground for Tallyfy's API - you'll figure out what's possible before committing to code. ## Prerequisites You'll need: - A Tallyfy account with API access - Postman desktop or web app (free at [postman.com](https://www.postman.com)[1]) - Your API credentials from **Settings > Integrations > REST API** in Tallyfy ## Quick setup > **Important** - The API uses different names than the Tallyfy UI. Templates are called `checklists` and processes are called `runs` in API endpoints. ## Common Tallyfy API operations Here are the most-used endpoints. All paths sit under `/organizations/{{TALLYFY_ORG_ID}}`. ### Launch a process from a template ``` POST /organizations/{{TALLYFY_ORG_ID}}/runs Body: { "checklist_id": "{{TEMPLATE_ID}}", "name": "My Process" } ``` ### Complete a task ``` POST /organizations/{{TALLYFY_ORG_ID}}/runs/{{RUN_ID}}/completed-tasks Body: { "task_id": "{{TASK_ID}}" } ``` ### List active processes ``` GET /organizations/{{TALLYFY_ORG_ID}}/runs?status=active ``` ### Upload a file ``` POST /organizations/{{TALLYFY_ORG_ID}}/upload ``` ## What's in this guide? The Postman guide is split into focused sections: ### Postman - **[Advanced patterns and testing](https://tallyfy.com/products/pro/integrations/open-api/api-clients/postman/advanced-patterns/)**: Use Postman's collection runners, Newman CLI, and monitors to automate Tallyfy API testing across multiple organizations. Covers CI/CD integration, performance monitoring, mock servers, and data-driven testing. Collection runners handle bulk operations. Newman plugs into CI/CD pipelines. Monitors run scheduled checks. Together, these patterns take you from manual API testing to automated workflow validation. ## Multi-organization testing If you work across several Tallyfy organizations, you'll want a fast way to switch between them during testing. ### Environment switching setup Create a pre-request script that rotates through your orgs automatically: ```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") } ]; let currentIndex = pm.variables.get("ORG_INDEX") || 0; 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`); const nextIndex = (currentIndex + 1) % orgs.length; pm.variables.set("ORG_INDEX", nextIndex); ``` ### Cross-org data comparison Compare processes across organizations after fetching from each: ```javascript const orgProcesses = pm.environment.get("ORG_PROCESSES") || {}; const currentOrg = pm.environment.get("TALLYFY_ORG_ID"); // Tallyfy wraps responses in a "data" property orgProcesses[currentOrg] = pm.response.json().data; pm.environment.set("ORG_PROCESSES", orgProcesses); const orgIds = Object.keys(orgProcesses); if (orgIds.length >= 2) { console.log("Process count comparison:"); orgIds.forEach(orgId => { console.log(`${orgId}: ${orgProcesses[orgId].length} active processes`); }); // Find processes with the same name across orgs const processNames = new Set(); orgIds.forEach(orgId => { orgProcesses[orgId].forEach(p => processNames.add(p.name)); }); 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 ### Response time tracking Add this to your collection's Tests tab to track response times over multiple runs: ```javascript pm.test("Response time is acceptable", function () { pm.expect(pm.response.responseTime).to.be.below(1000); }); 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); 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. Avg: ${avgTime}ms`); } ``` ### Endpoint performance comparison ```javascript const perfData = pm.environment.get("PERFORMANCE_DATA") || []; const endpointStats = {}; perfData.forEach(entry => { // Normalize UUIDs and numeric IDs to /:id const endpoint = entry.endpoint.replace(/\/[a-f0-9\-]{8,}/g, '/:id'); 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); }); Object.entries(endpointStats).forEach(([endpoint, stats]) => { const avg = (stats.totalTime / stats.count).toFixed(0); console.log(`${endpoint}: ${stats.count} calls, avg ${avg}ms, min ${stats.minTime}ms, max ${stats.maxTime}ms`); }); ``` ## Mock server setup Postman mock servers let you simulate API responses without hitting the real Tallyfy API. They match requests by HTTP method, path, query parameters, and headers like `x-mock-response-code` or `x-mock-response-name`. ### Capturing examples for mocks ```javascript // Save successful responses as mock examples if (pm.response.code >= 200 && pm.response.code < 400) { const examples = pm.environment.get("MOCK_EXAMPLES") || {}; const key = `${pm.request.method}_${pm.request.url.getPath().replace(/\//g, '_')}`; examples[key] = { request: { method: pm.request.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() }, timestamp: new Date().toISOString() }; pm.environment.set("MOCK_EXAMPLES", examples); } ``` ### Switching between mock and real servers ```javascript const mockConfig = { development: { useMock: true, mockUrl: "https://mock-server-123.pstmn.io" }, staging: { useMock: false, realUrl: "https://go.tallyfy.com/api" }, production: { useMock: false, realUrl: "https://go.tallyfy.com/api" } }; const env = pm.environment.get("TARGET_ENV") || "development"; const config = mockConfig[env]; if (config.useMock) { pm.request.url.host = config.mockUrl.replace(/https?:\/\//, '').split('/'); pm.request.url.protocol = "https"; const scenario = pm.environment.get("MOCK_SCENARIO") || "success"; pm.request.headers.add({ key: 'x-mock-response-name', value: scenario }); } ``` ### Error simulation ```javascript const errorSimulation = { "rate_limit": { headers: {"x-mock-response-code": "429"} }, "server_error": { headers: {"x-mock-response-code": "500"} }, "timeout": { headers: {"x-mock-response-code": "408"} } }; const simulateError = pm.environment.get("SIMULATE_ERROR"); if (simulateError && errorSimulation[simulateError]) { Object.entries(errorSimulation[simulateError].headers).forEach(([key, value]) => { pm.request.headers.add({key, value}); }); } ``` ## CI/CD integration ### Newman vs Postman CLI | 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 maturity** | Well-established | Newer, growing | | **Extensibility** | Rich plugin system | Limited but improving | ### Newman setup ```bash # Install Newman (requires Node.js v16+) npm install -g newman newman --version ``` ### Running collections with Newman ```bash # Basic run with 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 # Data-driven run newman run collection.json \ -e environment.json \ -d test-data.csv \ --iteration-count 5 # Stop on first failure newman run collection.json \ --bail failure \ --global-var "API_BASE=https://go.tallyfy.com/api" # Run a specific folder only newman run collection.json \ --folder "Authentication Tests" \ --env-var "SKIP_CLEANUP=true" ``` ### GitHub Actions integration Here's a working pipeline that tests against multiple environments: `.github/workflows/api-tests.yml`: ```yaml name: Tallyfy API Tests on: schedule: - cron: '0 */4 * * *' workflow_dispatch: push: branches: [main, develop] pull_request: branches: [main] env: NODE_VERSION: '18' jobs: api-tests: runs-on: ubuntu-latest strategy: matrix: environment: [staging, production] test-suite: [smoke, full] 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 run: npm install -g newman newman-reporter-htmlextra - name: Run API tests env: TALLYFY_CLIENT_ID: ${{ secrets[format('TALLYFY_CLIENT_ID_{0}', matrix.environment)] }} TALLYFY_CLIENT_SECRET: ${{ secrets[format('TALLYFY_CLIENT_SECRET_{0}', matrix.environment)] }} 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 \ --reporter-json-export results-${{ matrix.environment }}-${{ matrix.test-suite }}.json \ --delay-request 100 \ --timeout-request 30000 \ --bail failure continue-on-error: true - name: Parse 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") echo "total_requests=$TOTAL" >> $GITHUB_OUTPUT echo "failed_requests=$FAILED" >> $GITHUB_OUTPUT fi - name: Upload artifacts uses: actions/upload-artifact@v4 if: always() with: name: test-results-${{ matrix.environment }}-${{ matrix.test-suite }} path: results-*.json retention-days: 30 - name: Fail on test failures if: steps.test-results.outputs.failed_requests > 0 run: | echo "API tests failed: ${{ steps.test-results.outputs.failed_requests }}/${{ steps.test-results.outputs.total_requests }}" exit 1 ``` ### Performance regression detection ```bash newman run collection.json \ --reporters cli,json \ --reporter-json-export current-results.json # Compare against a saved baseline node scripts/performance-comparison.js \ --baseline baseline-results.json \ --current current-results.json \ --threshold 20 ``` ### Data-driven testing Postman supports CSV and JSON data files. CSV works for flat data; JSON handles nested structures. **CSV example** - `test-data.csv`: ```csv process_name,template_id,assignee,expected_status "Q1 Budget Review","template_123","john@company.com","active" "Employee Onboarding","template_456","hr@company.com","pending" ``` **JSON example** - `test-data.json`: ```json [ { "process_name": "Q1 Budget Review", "template_id": "template_123", "assignee": "john@company.com", "kick_off_data": { "field_department": "Finance", "field_budget_amount": 50000 }, "expected_tasks": 5, "validation_rules": { "response_time_max": 2000, "required_fields": ["id", "name", "status"] } } ] ``` **Using data variables in tests**: ```javascript const expectedTasks = parseInt(pm.variables.get("expected_tasks")); const validationRules = JSON.parse(pm.variables.get("validation_rules") || '{}'); pm.test(`Process has ${expectedTasks} tasks`, () => { const response = pm.response.json(); pm.expect(response.data.tasks).to.have.lengthOf(expectedTasks); }); if (validationRules.response_time_max) { pm.test(`Response under ${validationRules.response_time_max}ms`, () => { pm.expect(pm.response.responseTime).to.be.below(validationRules.response_time_max); }); } if (validationRules.required_fields) { validationRules.required_fields.forEach(field => { pm.test(`Has field: ${field}`, () => { pm.expect(pm.response.json().data).to.have.property(field); }); }); } ``` **Error scenario data file**: ```json [ { "scenario": "invalid_template_id", "template_id": "invalid_123", "expected_status": 404 }, { "scenario": "missing_required_field", "template_id": "template_123", "kick_off_data": {}, "expected_status": 422 } ] ``` ```javascript const scenario = pm.variables.get("scenario"); const expectedStatus = parseInt(pm.variables.get("expected_status")); pm.test(`${scenario} returns ${expectedStatus}`, () => { pm.expect(pm.response.code).to.equal(expectedStatus); }); ``` ## Collection runner patterns ### Workflow simulation Structure your collection to mirror a full workflow, passing data between requests: ```javascript // Collection order: // 1. Authenticate // 2. Create process (POST /organizations/{org}/runs) // 3. Complete tasks (PUT /organizations/{org}/runs/{run}/tasks/{task}) // 4. Add comment // 5. Verify process complete // In "Create Process" Tests tab - note the .data wrapper: const processId = pm.response.json().data.id; pm.collectionVariables.set("CURRENT_PROCESS_ID", processId); // Subsequent requests reference {{CURRENT_PROCESS_ID}} ``` ### Parallel API calls Fire multiple requests at once to compare response times: ```javascript async function parallelOperations() { const operations = [ { name: "List Templates", endpoint: "/checklists" }, { name: "List Processes", endpoint: "/runs" }, { name: "List Tasks", endpoint: "/me/tasks" }, { name: "List Users", endpoint: "/users" } ]; 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 })) ) ); results.forEach(r => { console.log(`${r.name}: ${r.count} items in ${r.time}ms`); }); } parallelOperations(); ``` ## Monitoring and alerting ### Scheduled monitors Postman monitors run collections on a schedule. Two things worth monitoring: **Stuck process detection**: ```javascript 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)) / 3600000; return hoursSinceUpdate > 24 && p.status === 'active'; }).length; pm.expect(stuckCount).to.equal(0); }); ``` **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 alerts on failure ```javascript if (pm.test.failures && pm.test.failures.length > 0) { pm.sendRequest({ url: pm.environment.get("SLACK_WEBHOOK_URL"), 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") }, { title: "Environment", value: pm.environment.name, short: true }, { title: "Time", value: new Date().toISOString(), short: true } ] }] }) } }); } ``` ## Performance optimization ### Adaptive request delays ```javascript // Slow down when the API responds slowly const lastResponseTime = pm.environment.get("LAST_RESPONSE_TIME"); if (lastResponseTime > 2000) { pm.environment.set("REQUEST_DELAY", 500); } else { pm.environment.set("REQUEST_DELAY", 100); } ``` ### Memory cleanup between iterations ```javascript ["TEMP_PROCESS_ID", "TEMP_TASK_DATA", "CACHED_RESPONSE", "ITERATION_STATE"] .forEach(key => pm.environment.unset(key)); ``` - **[Authentication setup for Postman](https://tallyfy.com/products/pro/integrations/open-api/api-clients/postman/authentication-setup/)**: Set up Tallyfy API authentication in Postman using OAuth 2.0 with the password grant type. Store credentials as environment variables, configure automatic token storage, and include the required Bearer token and X-Tallyfy-Client header. Tallyfy's API uses OAuth 2.0 with the password grant type. Most endpoints need user context, so you'll configure Postman with your credentials, set up the required headers, and store tokens automatically. ## What you need to know first Here's what trips people up: - **Password grant is required** -- most endpoints need user context, not just application-level access - **The `X-Tallyfy-Client` header is required** -- include it on every request - **Access tokens last 6 months** -- refresh tokens last 12 months - **Client credentials grant is limited** -- those tokens only last 7 days and can't access user-scoped endpoints ## Setting up authentication step by step ## Authentication flow visualization This diagram shows the OAuth lifecycle -- initial token grant, API usage, and token refresh. [Diagram removed for brevity] **What to notice:** - **Steps 1-3** -- the password grant requires all four parameters (username, password, client_id, client_secret) - **Step 5** -- every API call needs both the Bearer token and the `X-Tallyfy-Client` header - **Steps 9-12** -- refresh happens before expiry using the stored refresh token ## The required headers Every API request needs two headers. Add them to your collection's pre-request script so you don't have to set them manually each time: ```javascript pm.request.headers.add({ key: 'X-Tallyfy-Client', value: 'APIClient' }); const token = pm.environment.get("TALLYFY_ACCESS_TOKEN"); if (token) { pm.request.headers.add({ key: 'Authorization', value: `Bearer ${token}` }); } ``` ## Token refresh Access tokens last 6 months and refresh tokens last 12 months. You probably won't hit expiry during a testing session, but here's a pre-request script that handles refresh automatically: ```javascript const tokenExpiry = pm.environment.get("TALLYFY_TOKEN_EXPIRY"); const now = new Date().getTime(); 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); pm.environment.set("TALLYFY_TOKEN_EXPIRY", now + (response.expires_in * 1000)); console.log("Token refreshed successfully"); } else { console.error("Token refresh failed - request a new token manually"); } }); } } ``` ## Grant types compared | Grant type | What it does | When to use | |------------|--------------|-------------| | password | Full user context -- access all endpoints | API testing in Postman | | client_credentials | Application-only access (7-day tokens) | Automated system integrations | | refresh_token | Gets a new access token | When your current token expires | Use password grant for Postman testing. Client credentials won't give you access to user-scoped endpoints like templates, processes, or tasks. ## Security tips - Mark sensitive variables as **secret** in Postman so they're masked - Use the initial/current value distinction -- initial values sync with your team, current values stay local - Don't commit exported environments to version control - When sharing collections, export them without the environment and document which variables teammates need to create ## Common errors and fixes **401 Unauthenticated:** 1. Missing `X-Tallyfy-Client: APIClient` header 2. Token has expired -- request a new one or check your refresh script 3. Using `client_credentials` grant for a user-scoped endpoint -- switch to `password` 4. Malformed Authorization header -- it should be `Bearer [token]` with exactly one space **400 Bad Request on the token endpoint:** - Body must be `x-www-form-urlencoded`, not JSON - All parameters (grant_type, username, password, client_id, client_secret) must be present **Invalid client:** - Double-check your Client ID and Client Secret - Make sure you're using the right Postman environment ## Testing your setup Send this request to confirm everything works: ``` GET {{TALLYFY_BASE_URL}}/me Headers: Authorization: Bearer {{TALLYFY_ACCESS_TOKEN}} X-Tallyfy-Client: APIClient Accept: application/json ``` If you get your user details back, you're all set. ## Next steps With authentication working, you can: - [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/) - **[Postman collection organization](https://tallyfy.com/products/pro/integrations/open-api/api-clients/postman/collection-organization/)**: Organize Postman collections around Tallyfy's API resources with folder prefixes and consistent naming conventions. Good structure cuts errors and speeds up integration work. Group your Postman requests by resource type, use folders for workflows, and stick to consistent naming conventions. A well-structured collection cuts errors and speeds up your Tallyfy integration work from day one. ## Collection structure patterns ### Resource-based organization Structure your collection to mirror Tallyfy's actual API resources. The API organizes around templates (called "checklists" internally), processes (runs), tasks, assets, members, guests, and groups. ``` 📁 Tallyfy API Collection 📁 [SETUP] Authentication - Get Access Token (Password Grant) - Refresh Access Token - Test Authentication 📁 [CORE] Templates (Checklists) - List All Templates - Get Template Details - Create Template - Update Template - Clone Template - Get Template Permissions - Export Template 📁 [CORE] Processes (Runs) - Launch Process from Template - Launch with Kick-off Data - List Active Processes - Get Process Details - Update Process - Archive Process - Export Process Data 📁 [CORE] Tasks - List My Tasks - List Org Tasks - Get Task Details - Update Task - Mark Task Complete - Add Task Comment - Report Problem on Task 📁 [UTILS] Files & Assets - Upload File - Get File / Asset - Delete File - Download File 📁 [ADMIN] Members & Groups - List Organization Members - Get Member Details - Invite New Member - Update Member Role - List Groups - Create / Update Group 📁 [UTILS] Guests - Create Guest - List Guests - Update Guest - Guest-to-Member Conversion 📁 [DEMO] Workflows (End-to-End) - Complete Onboarding Flow - Approval Process Demo ``` Bracket prefixes like [SETUP], [CORE], [UTILS], [ADMIN], and [DEMO] let team members quickly spot each folder's purpose and access level. ### Workflow-based organization For process-specific collections, organize by business workflow instead: ``` 📁 HR Processes Collection 📁 Employee Onboarding 📂 Setup - Authenticate - Get Onboarding Template 📂 Launch - Create New Employee Process 📂 Day 1 Tasks - Complete Paperwork Task - Upload Documents 📂 Verification - Check All Tasks Complete 📁 Performance Reviews ... 📁 Leave Requests ... ``` ## Naming conventions ### Request naming standards Clear, descriptive names save everyone time. Use this pattern: **Format**: `[METHOD] - [Action] [Resource] [Context]` ``` Good names: - POST - Launch Process from Template - GET - List Active Tasks for Current User - PUT - Update Task with Form Data - DELETE - Archive Completed Process - GET - Get Template with Steps and Permissions Bad names: - Test - New Request - API Call 1 - Copy of Launch Process ``` You can layer in extra context with prefixes: ``` // Environment-specific - [PROD] GET - List Templates - [STAGE] POST - Launch Test Process // User context - [ADMIN] PUT - Update Organization Settings - [GUEST] POST - Submit External Form // Workflow sequence - [1] POST - Authenticate User - [2] GET - Fetch Available Templates - [3] POST - Launch Selected Process - [4] PUT - Complete First Task ``` ### Variable naming standards Pick a consistent naming convention per scope and stick to it: ```javascript // Environment variables (UPPERCASE with prefix) TALLYFY_BASE_URL TALLYFY_ORG_ID TALLYFY_ACCESS_TOKEN TALLYFY_CLIENT_ID // Collection variables (PascalCase) CurrentProcessId ActiveTemplateId TestUserEmail // Request-local variables (camelCase) const taskCount = 5; const processName = "Onboarding"; ``` Use the right scope for each variable's lifecycle: ```javascript // Environment: config that changes per environment pm.environment.set("TALLYFY_BASE_URL", "https://go.tallyfy.com/api"); // Collection: shared across requests in this collection pm.collectionVariables.set("CurrentSessionId", sessionId); // Local: single request only pm.variables.set("tempCalculation", result); // Clean up temporary variables after use pm.test("Cleanup", () => { ["TEMP_AUTH_STATE", "TEMP_UPLOAD_TOKEN"].forEach(key => { pm.environment.unset(key); }); }); ``` ### Folder prefixes and organization Standardized prefixes make structure self-documenting: ``` 📁 [SETUP] - Authentication & Configuration 📁 [CORE] - Primary Business Operations 📁 [UTILS] - Helper Requests & Utilities 📁 [TEST] - Testing Scenarios & Validation 📁 [DEMO] - Example Workflows & Training 📁 [ADMIN] - Administrative Operations 📁 [DEPRECATED] - Legacy Requests (Keep for Reference) ``` Numeric prefixes enforce ordering: ``` 📁 01-Authentication 📁 02-Templates 📁 03-Processes 📁 04-Tasks 📁 05-Files 📁 06-Admin 📁 99-Utilities ``` ## Documentation standards ### Collection description A solid collection description cuts support questions. Here's a template that works well: ```markdown # Tallyfy API Collection ## Overview Complete coverage of Tallyfy's REST API for workflow automation. ## 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 ## Quick start 1. Import this collection 2. Create an environment with required variables (see below) 3. Run "[SETUP] Get Access Token" first 4. Verify with any GET request ## Required environment variables | Variable | Description | Example | |----------|-------------|----------| | `TALLYFY_BASE_URL` | API base URL | `https://go.tallyfy.com/api` | | `TALLYFY_CLIENT_ID` | OAuth client ID | Your client ID | | `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 | Your org ID | ## Security - Use Postman Vault for passwords and secrets - Never commit environment files with real credentials - Use separate environments for production and staging ## Common issues | Issue | Cause | Fix | |-------|-------|-----| | 401 Unauthorized | Missing X-Tallyfy-Client header | Add header via pre-request script | | Token expired | Tokens last ~1 hour | Run "Refresh Access Token" | | File upload fails | Manual Content-Type set | Remove Content-Type, use form-data | ``` ### Request documentation Document individual requests so teammates don't have to guess. Here's a good template, using the task update endpoint as an example: ```markdown ## Update task with form data ### Description Updates a task and submits form field data. The API endpoint is PUT /organizations/{org}/runs/{run_id}/tasks/{task} ### Prerequisites - Valid Bearer token and X-Tallyfy-Client header - Task must exist within the specified run - User must have access to the task ### Request body ```json { "taskdata": { "field_alias": "value" } } ``` ### Error responses | Code | Reason | Fix | |------|--------|-----| | 401 | Auth failed | Check token and X-Tallyfy-Client header | | 403 | No access | Verify task assignment | | 404 | Not found | Check task ID, run ID, and org ID | | 422 | Validation error | Check required fields and data types | ### Test script ```javascript pm.test("Task updated", () => { pm.expect(pm.response.code).to.equal(200); const body = pm.response.json(); pm.expect(body.data).to.exist; }); ``` ### Related endpoints - `GET /organizations/{org}/runs/{run_id}/tasks/{task}` - Get task details - `POST /organizations/{org}/tasks/{task}/comment` - Add comment ``` ## Environment management ### Environment setup Tallyfy's API uses the same base URL for all environments - you differentiate by org ID: ```javascript // Production { "TALLYFY_BASE_URL": "https://go.tallyfy.com/api", "TALLYFY_ORG_ID": "your_prod_org_id", "LOG_LEVEL": "ERROR" } // Staging / testing { "TALLYFY_BASE_URL": "https://go.tallyfy.com/api", "TALLYFY_ORG_ID": "your_test_org_id", "LOG_LEVEL": "DEBUG" } ``` ## Pre-request scripts ### Collection-level script Add this to your collection so every request gets the right headers automatically: ```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}` }); } ``` ### Folder-level scripts You can add behavior scoped to specific folders: ```javascript // For "Files" folder - log upload requests if (pm.request.body && pm.request.body.mode === 'formdata') { console.log("File upload request detected"); } // For "Admin" folder - extra logging console.log("Admin operation:", pm.request.name); ``` ## Test organization ### Shared test functions Build reusable test utilities at the collection level: ```javascript // In collection Tests tab pm.collectionVariables.set("testUtils", { expectSuccess: function(responseCode = 200) { pm.test(`Status code is ${responseCode}`, () => { pm.expect(pm.response.code).to.equal(responseCode); }); }, expectFields: function(fields) { pm.test("Response has required fields", () => { const json = pm.response.json(); fields.forEach(field => { pm.expect(json).to.have.property(field); }); }); }, saveId: function(idField, variableName) { const id = pm.response.json()[idField]; if (id) { pm.collectionVariables.set(variableName, id); console.log(`Saved ${variableName}: ${id}`); } } }); // Usage in any request's tests: const utils = pm.collectionVariables.get("testUtils"); utils.expectSuccess(201); utils.expectFields(['data']); utils.saveId('id', 'lastProcessId'); ``` ## Version control ### Exporting for Git Keep your Postman work in version control: 1. Export collection as v2.1 format, including collection variables but excluding environment secrets. 2. Use a clean directory structure: ``` postman/ collections/ tallyfy-api.json environments/ production.template.json staging.template.json ``` 3. Environment templates should use placeholder values: ```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" } ] } ``` ## Sharing and collaboration ### Team workspace setup Organize workspaces by access level: 1. **Official Collections** - View-only for most team members. Contains the canonical Tallyfy API collection. 2. **Team Collections** - Editable by department. HR workflows, finance processes, etc. 3. **Personal** - Private drafts and experiments. Fork official collections for experiments, then submit pull requests for improvements you want to share back. ## Maintenance practices Keep collections healthy with regular upkeep: 1. **Trim pre-request scripts** - only keep what's needed 2. **Archive old requests** - move deprecated requests to a separate folder or collection 3. **Review variables** - remove unused environment and collection variables 4. **Update documentation** - keep request descriptions current when the API changes ## Advanced organization ### DRY pre-request scripts Put shared logic at the collection level so you don't repeat it in every request: ```javascript // Collection-level pre-request: runs before every request if (!pm.request.headers.has("X-Tallyfy-Client")) { pm.request.headers.add({ key: "X-Tallyfy-Client", value: "APIClient" }); } // Check token expiry const tokenExpiry = pm.environment.get("TALLYFY_TOKEN_EXPIRY"); if (tokenExpiry && Date.now() >= tokenExpiry - 300000) { console.log("Token expires soon - run refresh request"); } ``` ### Multi-level folder structure Postman supports nested folders. Use them for large collections: ``` 📁 Tallyfy API Collection 📁 [CORE] Templates 📁 Template CRUD - Create Template - Get Template - Update Template - Delete Template 📁 Template Operations - Launch Process from Template - Clone Template - Export Template 📁 [CORE] Processes 📁 Lifecycle - Launch from Template - Update Process - Archive Process - Export Data ``` ### Request dependencies Track which requests depend on others: ```javascript const dependencies = { "Complete Task": ["Get Task Details", "Authenticate"], "Launch Process": ["Get Template", "Authenticate"], "Upload File": ["Authenticate"] }; const currentRequest = pm.info.requestName; const requiredDeps = dependencies[currentRequest] || []; requiredDeps.forEach(dep => { const depDone = pm.environment.get( `DEP_${dep.replace(/\s+/g, '_').toUpperCase()}` ); if (!depDone) { console.warn(`Dependency not met: ${dep}`); } }); // Mark this request as completed on success pm.test("Mark dependency completed", () => { if (pm.response.code < 400) { pm.environment.set( `DEP_${currentRequest.replace(/\s+/g, '_').toUpperCase()}`, true ); } }); ``` A well-organized collection pays for itself quickly. Spend time on structure upfront and you'll save hours of confusion later. - **[Task operations and automation](https://tallyfy.com/products/pro/integrations/open-api/api-clients/postman/task-operations/)**: Tallyfy's API lets you list, complete, and update tasks through Postman. Filter by status or assignee, save form field data, handle file uploads, and manage assignments and comments. Tasks are individual work items inside a running process. You can list, complete, update, and comment on tasks through the API using Postman. ## Task structure In Tallyfy's API: - **Tasks** - individual work items in a running process (or standalone one-off tasks) - **Captures** - form field values within tasks (saved via a separate endpoint) - **Owners** - who's assigned to complete the task (users, guests, or groups) ## 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 Accept: application/json Query parameters: - status: active, completed, overdue, due_soon, hasproblem - per_page: 10 (default) - page: 1 - sort: deadline, newest, problems, -deadline ``` ### Get all tasks in a process ``` GET {{TALLYFY_BASE_URL}}/organizations/{{TALLYFY_ORG_ID}}/runs/{{RUN_ID}}/tasks Query parameters: - status: active, complete, overdue, not-started, auto-skipped - sort: position, deadline, -position, -deadline - with: step,form_fields,threads,assets,summary ``` ### 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.owners && t.owners.users && t.owners.users.some(u => u.id === 10001) ); console.log(`Found ${overdueTasks.length} overdue tasks`); ``` ## Completing tasks Task completion uses a `POST` to the `completed-tasks` endpoint, not a `PUT`. You send the `task_id` in the request body. ### Complete a process task ``` POST {{TALLYFY_BASE_URL}}/organizations/{{TALLYFY_ORG_ID}}/runs/{{RUN_ID}}/completed-tasks Headers: Authorization: Bearer {{TALLYFY_ACCESS_TOKEN}} X-Tallyfy-Client: APIClient Accept: application/json Content-Type: application/json Body: { "task_id": "{{TASK_ID}}", "is_approved": true } ``` The `is_approved` field is optional and only applies to approval-type tasks. ### Complete a one-off task ``` POST {{TALLYFY_BASE_URL}}/organizations/{{TALLYFY_ORG_ID}}/completed-tasks Body: { "task_id": "{{TASK_ID}}" } ``` ### Save form field data before completing You'll save form field values (captures) through a separate endpoint before completing the task: ``` POST {{TALLYFY_BASE_URL}}/organizations/{{TALLYFY_ORG_ID}}/tasks/{{TASK_ID}}/captures Body: { "id": "field_abc123", "value": "Approved" } ``` Each capture call saves one field at a time. Send multiple requests to fill several fields, then complete the task. ### Bulk task completion Complete multiple tasks in a process: ```javascript const runId = pm.environment.get("RUN_ID"); const taskIds = ["task_123", "task_456", "task_789"]; const results = []; function completeTask(taskId) { return new Promise((resolve, reject) => { pm.sendRequest({ url: `${pm.environment.get("TALLYFY_BASE_URL")}/organizations/${pm.environment.get("TALLYFY_ORG_ID")}/runs/${runId}/completed-tasks`, method: 'POST', header: { 'Authorization': `Bearer ${pm.environment.get("TALLYFY_ACCESS_TOKEN")}`, 'X-Tallyfy-Client': 'APIClient', 'Accept': 'application/json', 'Content-Type': 'application/json' }, body: { mode: 'raw', raw: JSON.stringify({ task_id: taskId }) } }, (err, res) => { if (err) { reject(err); } else { resolve({ taskId, status: res.code }); } }); }); } async function completeTasks() { for (let i = 0; i < taskIds.length; i++) { try { const result = await completeTask(taskIds[i]); results.push(result); console.log(`Completed task ${i + 1} of ${taskIds.length}`); 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 a file File uploads use the assets endpoint with multipart/form-data. **Tips from Postman experts:** - **Don't set Content-Type manually** - Postman automatically sets `multipart/form-data` with the correct boundary. Setting it yourself causes "Missing start boundary" errors. - **Boundary handling** - the boundary separates form parts. Postman generates it automatically. ### Download a file ``` GET {{TALLYFY_BASE_URL}}/organizations/{{TALLYFY_ORG_ID}}/download-files/{{FILE_ID}} Headers: Authorization: Bearer {{TALLYFY_ACCESS_TOKEN}} X-Tallyfy-Client: APIClient Accept: application/json ``` Save the response using Postman's "Save Response" then "Save to a file" option. ## Task assignment patterns ### Reassign a task Update task assignments using the `owners` object with `users`, `guests`, and `groups` sub-fields: ``` PUT {{TALLYFY_BASE_URL}}/organizations/{{TALLYFY_ORG_ID}}/runs/{{RUN_ID}}/tasks/{{TASK_ID}} Body: { "owners": { "users": [10001, 10002], "guests": ["contractor@example.com"], "groups": [] } } ``` ### Dynamic assignment based on workload Assign to the least busy team member: ```javascript async function assignToLeastBusy(runId, taskId) { // Get task counts for candidate users const userIds = [10001, 10002, 10003]; const taskCounts = await Promise.all(userIds.map(async (userId) => { const tasksResponse = await new Promise((resolve, reject) => { pm.sendRequest({ url: `${pm.environment.get("TALLYFY_BASE_URL")}/organizations/${pm.environment.get("TALLYFY_ORG_ID")}/users/${userId}/tasks?status=active&without_pagination=true`, method: 'GET', header: { 'Authorization': `Bearer ${pm.environment.get("TALLYFY_ACCESS_TOKEN")}`, 'X-Tallyfy-Client': 'APIClient', 'Accept': 'application/json' } }, (err, res) => err ? reject(err) : resolve(res)); }); return { userId, taskCount: tasksResponse.json().data.length }; })); const leastBusy = taskCounts.reduce((prev, current) => prev.taskCount < current.taskCount ? prev : current ); console.log(`Assigning to user ${leastBusy.userId} (${leastBusy.taskCount} active tasks)`); // Assign the task return new Promise((resolve, reject) => { pm.sendRequest({ url: `${pm.environment.get("TALLYFY_BASE_URL")}/organizations/${pm.environment.get("TALLYFY_ORG_ID")}/runs/${runId}/tasks/${taskId}`, method: 'PUT', header: { 'Authorization': `Bearer ${pm.environment.get("TALLYFY_ACCESS_TOKEN")}`, 'X-Tallyfy-Client': 'APIClient', 'Accept': 'application/json', 'Content-Type': 'application/json' }, body: { mode: 'raw', raw: JSON.stringify({ owners: { users: [leastBusy.userId] } }) } }, (err, res) => err ? reject(err) : resolve(res)); }); } ``` ## Task comments ### Add a comment to a task The comment endpoint uses the singular `/comment`, not `/comments`: ``` POST {{TALLYFY_BASE_URL}}/organizations/{{TALLYFY_ORG_ID}}/tasks/{{TASK_ID}}/comment Headers: Authorization: Bearer {{TALLYFY_ACCESS_TOKEN}} X-Tallyfy-Client: APIClient Accept: application/json Content-Type: application/json Body: { "content": "Please review the attached documents before approving." } ``` ### Task escalation for overdue items Find and escalate overdue tasks: ```javascript 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; }); overdueTasks.forEach(task => { const hoursOverdue = Math.floor((now - new Date(task.deadline)) / (1000 * 60 * 60)); pm.sendRequest({ url: `${pm.environment.get("TALLYFY_BASE_URL")}/organizations/${pm.environment.get("TALLYFY_ORG_ID")}/tasks/${task.id}/comment`, method: 'POST', header: { 'Authorization': `Bearer ${pm.environment.get("TALLYFY_ACCESS_TOKEN")}`, 'X-Tallyfy-Client': 'APIClient', 'Accept': 'application/json', 'Content-Type': 'application/json' }, body: { mode: 'raw', raw: JSON.stringify({ content: `ESCALATION: This task is ${hoursOverdue} hours overdue. Manager notified.` }) } }); }); ``` ## Troubleshooting task operations ### "Cannot complete task" errors Common causes: - Task already completed - You aren't assigned to the task (and `can_complete_only_assignees` is on) - Required form fields haven't been filled (save captures first) - Previous dependencies aren't complete yet ### File upload issues - Use `multipart/form-data`, not JSON - Don't manually set `Content-Type` - let Postman handle it - Include `subject_id` and `subject_type` fields ### Pagination Task list endpoints use `page` and `per_page` (default 10), not `limit`/`offset`: ``` GET .../me/tasks?status=active&per_page=50&page=1 ``` Set `without_pagination=true` to get all results in one response. ## Next steps With task automation set up: - [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/)**: Tallyfy's API lets you launch processes from templates by posting to the runs endpoint with a checklist ID and optional kick-off form data. It also supports dynamic template selection and bulk launching through Postman scripts. To launch Tallyfy processes from templates via the API in Postman, you'll create a run by posting to the runs endpoint with the template's checklist ID and optional kick-off form data. ## API naming vs UI naming Quick refresher on Tallyfy terminology: - **Templates** = Blueprints that define your workflow (the API calls them "checklists") - **Processes** = Running instances of templates (the API calls them "runs") - **Kick-off forms** = Data collected before launching (the API calls them "prerun") This naming difference catches everyone. Just remember: Template equals Checklist, Process equals Run. ## Template to process launch flow This diagram shows the 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 - **Step 5**: Kick-off form data (`prerun`) gets validated before the run is created - **Step 8**: The response includes the run ID you'll need for all 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 Accept: application/json ``` Response includes: ```json { "data": [ { "id": "checklist_abc123", "name": "Employee Onboarding", "guidance": "Standard process for new hires", "prerun": [ { "id": "a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6", "alias": "employee_name", "label": "Employee Name", "field_type": "text" } ] } ] } ``` **Pro tip**: Save template IDs as Postman environment variables for easy reuse. ## Getting template details To see a template's full structure including kick-off form fields and steps: ``` GET {{TALLYFY_BASE_URL}}/organizations/{{TALLYFY_ORG_ID}}/checklists/{{CHECKLIST_ID}}?with=steps Headers: Authorization: Bearer {{TALLYFY_ACCESS_TOKEN}} X-Tallyfy-Client: APIClient Accept: application/json ``` The `prerun` array in the response contains all kick-off form fields with their IDs, labels, and types. ## Launching a process ### Basic launch (no kick-off form) Create a process by posting to the runs endpoint with a `checklist_id`: ``` POST {{TALLYFY_BASE_URL}}/organizations/{{TALLYFY_ORG_ID}}/runs Headers: Authorization: Bearer {{TALLYFY_ACCESS_TOKEN}} X-Tallyfy-Client: APIClient Content-Type: application/json Accept: application/json Body: { "checklist_id": "{{CHECKLIST_ID}}", "name": "Onboarding - Jane Smith" } ``` The `checklist_id` field is required. It must be the template's timeline ID (a 32-character UUID without hyphens). ### Launch with kick-off form data Most templates have kick-off forms. Here's how to pre-fill them: ```json { "checklist_id": "{{CHECKLIST_ID}}", "name": "Purchase Request - MacBook Pro", "prerun": { "a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6": "John Smith", "3c9d1e7fa4b820516d8e2f7a9c0b4d15": "2499.99", "9f2b7c1e4a6d8035b1c7e9d2f4a6b801": "Engineering team needs upgraded hardware" } } ``` Note the field name is `prerun` (singular), not `preruns`. Every key inside `prerun` is a kick-off field's timeline ID, a 32-character hex string. Field labels and aliases like `requested_by` won't match anything, and Tallyfy discards unmatched keys without an error - the launch returns `201 Created` with that field left empty. Each `prerun` value's shape depends on the field type. The per-type list lives on [Launch process](/products/pro/integrations/open-api/code-samples/processes/launch-process/). ### Finding kick-off field IDs Three ways to find kick-off form field IDs: 1. **Chrome DevTools method** (easiest): - Launch a process manually in Tallyfy - Open the Network tab - Look for the POST request to `/runs` - Copy field IDs from the `prerun` object in the payload 2. **API exploration**: ``` GET {{TALLYFY_BASE_URL}}/organizations/{{TALLYFY_ORG_ID}}/checklists/{{CHECKLIST_ID}} ``` Look for `prerun` in the response - it contains an array of field objects. The `id` on each one is the timeline ID you use as a key. The `alias` next to it looks tempting but won't match. 3. **Form fields endpoint**: ``` GET {{TALLYFY_BASE_URL}}/organizations/{{TALLYFY_ORG_ID}}/checklists/{{CHECKLIST_ID}}/form-fields ``` ## Advanced launch patterns ### Launch with task assignments Override task assignees during launch using the `tasks` object keyed by step timeline ID: ```json { "checklist_id": "{{CHECKLIST_ID}}", "name": "Q1 Budget Review", "tasks": { "step_timeline_id_1": { "owners": { "users": ["user_id_123", "user_id_456"], "guests": ["guest@example.com"], "groups": ["group_id_789"] } } }, "users": ["user_id_123", "user_id_456"] } ``` You can also assign users and groups at the process level with the `users` and `groups` arrays. ### Conditional launch based on data Use Postman's pre-request scripts for dynamic launches: ```javascript // Determine template based on request amount const amount = pm.variables.get("purchase_amount"); let checklistId; if (amount < 1000) { checklistId = "checklist_simple"; } else if (amount < 10000) { checklistId = "checklist_manager_approval"; } else { checklistId = "checklist_executive_approval"; } pm.variables.set("CHECKLIST_ID", checklistId); ``` ### Bulk process launching Launch multiple processes efficiently: ```javascript const employees = [ { name: "Alice Johnson", dept: "Engineering", start: "2026-02-01" }, { name: "Bob Smith", dept: "Sales", start: "2026-02-05" }, { name: "Carol White", dept: "Marketing", start: "2026-02-10" } ]; employees.forEach((emp, index) => { setTimeout(() => { pm.sendRequest({ url: `${pm.environment.get("TALLYFY_BASE_URL")}/organizations/${pm.environment.get("TALLYFY_ORG_ID")}/runs`, method: 'POST', header: { 'Authorization': `Bearer ${pm.environment.get("TALLYFY_ACCESS_TOKEN")}`, 'X-Tallyfy-Client': 'APIClient', 'Content-Type': 'application/json', 'Accept': 'application/json' }, body: { mode: 'raw', raw: JSON.stringify({ checklist_id: pm.environment.get("ONBOARDING_CHECKLIST_ID"), name: `Onboarding - ${emp.name}`, // prerun keys are kick-off field timeline IDs, not field names prerun: { 'a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6': emp.name, // Employee name '3c9d1e7fa4b820516d8e2f7a9c0b4d15': emp.dept, // Department '9f2b7c1e4a6d8035b1c7e9d2f4a6b801': emp.start // Start date } }) } }, (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 Headers: Authorization: Bearer {{TALLYFY_ACCESS_TOKEN}} X-Tallyfy-Client: APIClient Accept: application/json Query parameters: - status: active, complete, problem, archived, delayed - per_page: 10 (default) - with: checklist,tasks_meta ``` ### Get process details ``` GET {{TALLYFY_BASE_URL}}/organizations/{{TALLYFY_ORG_ID}}/runs/{{RUN_ID}}?with=tasks,checklist Headers: Authorization: Bearer {{TALLYFY_ACCESS_TOKEN}} X-Tallyfy-Client: APIClient Accept: application/json ``` Returns the full process including task statuses, assigned members, form field values, and comments. ### Update process metadata ``` PUT {{TALLYFY_BASE_URL}}/organizations/{{TALLYFY_ORG_ID}}/runs/{{RUN_ID}} Headers: Authorization: Bearer {{TALLYFY_ACCESS_TOKEN}} X-Tallyfy-Client: APIClient Content-Type: application/json Accept: application/json Body: { "name": "Updated Process Name", "owner_id": "new_owner_user_id" } ``` ### Archive a process (soft delete) ``` DELETE {{TALLYFY_BASE_URL}}/organizations/{{TALLYFY_ORG_ID}}/runs/{{RUN_ID}} Headers: Authorization: Bearer {{TALLYFY_ACCESS_TOKEN}} X-Tallyfy-Client: APIClient Accept: application/json ``` To unarchive (reactivate) a process: ``` PUT {{TALLYFY_BASE_URL}}/organizations/{{TALLYFY_ORG_ID}}/runs/{{RUN_ID}}/activate ``` ## Process monitoring in Postman ### 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.last_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})`); }); pm.environment.set("STUCK_PROCESSES", JSON.stringify(stuckProcesses)); } ``` ### Track completion rates by template ```javascript // After getting all processes const processes = pm.response.json().data; const stats = {}; processes.forEach(p => { const checklistId = p.checklist_id; if (!stats[checklistId]) { stats[checklistId] = { total: 0, completed: 0 }; } stats[checklistId].total++; if (p.status === 'complete') { stats[checklistId].completed++; } }); Object.entries(stats).forEach(([checklistId, data]) => { const rate = (data.completed / data.total * 100).toFixed(1); console.log(`Checklist ${checklistId}: ${rate}% completion rate`); }); ``` ## Common pitfalls and solutions ### "Template not found" errors - Verify the `checklist_id` is correct (32-character UUID, no hyphens) - Check the template isn't archived or in draft mode - Confirm you have launch permission for that template ### Kick-off form validation failures Common issues: - Required fields missing from `prerun` - Wrong data type (string vs number) - Invalid option for select fields Debug by getting template details first - the `prerun` array shows each field's type and requirements. ### Rate limiting If you're bulk launching: - Add delays between requests (200-500ms) - Batch in groups of 10-20 - Watch for 429 rate limit responses ## Next steps - [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/)**: Most Tallyfy API failures in Postman come from a missing X-Tallyfy-Client header, wrong grant type, or expired tokens. Fix 401, 404, 422 errors, rate limiting, and file upload issues with ready-to-use debugging scripts. 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 make sure tokens haven't expired. These three issues cause most Tallyfy API failures. ## Authentication errors ### 401 Unauthorized Here are the most common causes, in order of likelihood: 1. **Missing X-Tallyfy-Client header** ``` X-Tallyfy-Client: APIClient ``` Every request needs this header. It's how Tallyfy identifies the client type making API calls. 2. **Wrong grant type** - You used: `grant_type=client_credentials` - You need: `grant_type=password` - Client credentials grant is only for system-level app operations (tokens last 7 days). For user-context work, always use the password grant. 3. **Expired token** - Access tokens from the password grant last **6 months** (not 1 hour) - Refresh tokens last **12 months** - Client credentials tokens last **7 days** - If you're unsure, just re-authenticate and get a fresh token 4. **Bearer token format** ``` // Wrong formats: Authorization: Bearer[token] // no space Authorization: Bearer [token] // double space Authorization: [token] // missing Bearer // Correct (exactly one space): Authorization: Bearer [token] ``` ### 400 Bad request on /oauth/token The token endpoint requires URL-encoded form data, not JSON: **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=...&client_id=...&client_secret=... ``` ### Invalid client errors **"Invalid client" or "Client authentication failed"** means: 1. **Non-numeric client_id** - The API validates that `client_id` is numeric. If it's not, you'll get a 401 with `{"error": "invalid_client"}`. 2. **Credentials don't match** - Client ID and Secret must be from the same app registration, and the Organization ID must match. 3. **Special characters in secrets** - If a secret contains `+`, `/`, or `=`, make sure they're properly URL-encoded when sent as form data. ## Data and request errors ### 404 Not found The API returns two different 404 messages depending on the cause: - **Wrong URL path** returns: `{"error": true, "message": "API endpoint not found", "code": "ENDPOINT_NOT_FOUND"}` - **Missing resource** returns: `{"error": true, "message": "Resource not found", "code": "RESOURCE_NOT_FOUND"}` **Common path mistakes**: ```javascript // Wrong: /organization/ (singular) // Right: /organizations/ (plural) // Wrong: /templates/ (doesn't exist) // Right: /checklists/ (the actual endpoint) // Wrong: /processes/ (doesn't exist) // Right: /runs/ (the actual endpoint) // Wrong: /members/ (doesn't exist) // Right: /users/ (the actual endpoint) ``` **Wrong Organization ID** - Make sure you're using the org ID, not a user ID. Log what you're sending: ```javascript console.log("Org ID:", pm.environment.get("TALLYFY_ORG_ID")); console.log("Full URL:", pm.request.url.toString()); ``` ### 422 Unprocessable entity This means validation failed. The API returns errors in this format: ```json { "error": true, "errors": { "field_name": ["The field_name is required."] } } ``` **Common causes**: - Missing required fields (e.g., `name` when launching a process) - Wrong data types (sending `"100"` as a string instead of `100` as a number) - Invalid date format (use `YYYY-MM-DD`) - Invalid enum values for select/radio fields ### 403 Forbidden This typically means the authenticated user or client app doesn't have permission for the requested resource. For client credentials specifically, the API checks that the token's client app belongs to the same organization as the one in the URL. If the org doesn't match, you'll get `"You don't have application's permissions for this organization!"`. ## Rate limiting ### 429 Too many requests Tallyfy's API rate limit is **600 requests per minute** per authenticated user (or per IP for unauthenticated requests). This resets on a rolling 1-minute window, not on the hour. Trial accounts have additional rate limits on specific operations (like password updates: 3 per day). When rate limited, the API returns: ```json { "message": "You've reached the limit for [operation]. Please try again later.", "code": "RATE_LIMIT_EXCEEDED" } ``` The response includes `Retry-After` and `X-RateLimit-Remaining` headers. **Simple backoff approach**: ```javascript // If you get a 429, wait for the Retry-After header value if (pm.response.code === 429) { const retryAfter = pm.response.headers.get("Retry-After"); console.log(`Rate limited. Wait ${retryAfter} seconds before retrying.`); } ``` **Spacing out batch requests**: ```javascript // Add a delay between requests to stay under limits async function processItemsWithDelay(items, delayMs = 150) { for (const item of items) { await pm.sendRequest({...}); await new Promise(resolve => setTimeout(resolve, delayMs)); } } ``` ## File upload issues ### Files not uploading **Wrong body type** - file uploads must use `form-data`, not raw JSON: ``` Body: form-data - name: [File type, select your file] - uploaded_from: [Text, e.g., "ko_field" or a form field ID] - subject_type: [Text, "Template" or "Process"] - subject_id: [Text, the template or process ID] ``` **File too large** - Tallyfy's upload limit is **100MB**. **Don't set Content-Type manually** - When using form-data in Postman, let Postman set the `Content-Type` header automatically (it needs to include the boundary string). Manually setting `Content-Type: multipart/form-data` breaks the upload. ## Debugging helpers ### Pre-request debug script Add this to your collection's Pre-request Script to catch issues before they happen: ```javascript // Check required headers const headers = pm.request.headers.toObject(); if (!headers['Authorization']) { console.error("MISSING: Authorization header"); } if (!headers['X-Tallyfy-Client']) { console.error("MISSING: X-Tallyfy-Client header"); } // Check required environment variables ['TALLYFY_ORG_ID', 'TALLYFY_ACCESS_TOKEN', 'TALLYFY_BASE_URL'].forEach(key => { if (!pm.environment.get(key)) { console.error(`MISSING env var: ${key}`); } }); console.log(`Request: ${pm.request.method} ${pm.request.url.toString()}`); ``` ### Response analysis script Add this to your Tests tab for automatic error diagnosis: ```javascript const statusCode = pm.response.code; if (statusCode >= 400) { console.error(`Error ${statusCode}: ${pm.response.status}`); try { const body = pm.response.json(); if (body.message) { console.error(`Message: ${body.message}`); } if (body.errors) { console.error("Validation errors:"); Object.entries(body.errors).forEach(([field, msgs]) => { console.error(` ${field}: ${Array.isArray(msgs) ? msgs.join(', ') : msgs}`); }); } } catch (e) { console.error("Response body:", pm.response.text()); } } // Log rate limit status const remaining = pm.response.headers.get("X-RateLimit-Remaining"); if (remaining !== null) { console.log(`Rate limit remaining: ${remaining}`); } ``` ## Getting help ### Before contacting support 1. Open the Postman Console (View > Show Postman Console) and check the full request/response details 2. Verify all three required headers are present: `Authorization`, `X-Tallyfy-Client`, and `Accept` 3. Confirm your org ID and token are valid 4. Check the response body for specific error messages and codes **Include these details in any support request**: - Exact error message and HTTP status code - Full request URL (with method) - Response body - Your organization ID - Timestamp of the attempt ### 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/) ### Code samples - **[Managing files](https://tallyfy.com/products/pro/integrations/open-api/code-samples/files/)**: Tallyfy's API lets you upload files up to 100MB and attach them to tasks or kick-off forms. You can also download, get metadata for, and delete file assets. Tallyfy's API lets you upload files (up to 100MB) and attach them to tasks or kick-off forms. You can also download, retrieve metadata for, and delete those files through dedicated endpoints. You'll find request details and code examples on the individual pages below. - **[Authentication methods](https://tallyfy.com/products/pro/integrations/open-api/code-samples/authentication/)**: Tallyfy API authentication uses either a personal access token (lasting 6 months from Settings) or a client credentials OAuth flow (7-day tokens). Every request must include Authorization Bearer, Accept, and X-Tallyfy-Client headers. Every Tallyfy API request needs authentication. Pick the method that fits your use case: - **Personal access token** -- grab your token from **Settings > Integrations > REST API** in Tallyfy and pass it in the `Authorization` header. Tokens last 6 months and act as the logged-in user. Best for scripts, testing, and quick integrations. - **Client credentials flow** -- use a `client_id` and `client_secret` (provided by Tallyfy Support) to get an application-level token via `POST https://go.tallyfy.com/oauth/token`. App tokens last 7 days. Best for backend services that don't need a user session. ## Required headers Include these three headers on every API call: | Header | Value | | --- | --- | | `Authorization` | `Bearer {access_token}` | | `Accept` | `application/json` | | `X-Tallyfy-Client` | `APIClient` | Omitting `X-Tallyfy-Client` or `Accept` will cause requests to fail. - **[Managing guests](https://tallyfy.com/products/pro/integrations/open-api/code-samples/guests/)**: Tallyfy's API lets you manage external guest users who participate in tasks without full accounts. Create, list, retrieve, update, and delete guests using their URL-encoded email address as the identifier across organization-scoped endpoints. Guests are external users who participate in specific tasks or processes. They don't need a full member account. You can use the API to create, list, retrieve, update, and delete guests. Guest endpoints use the guest's **email address** (URL-encoded) as the identifier in the path, not a numeric ID. All endpoints are scoped to your organization at `https://go.tallyfy.com/api/organizations/{org_id}/guests`. - **[Managing groups](https://tallyfy.com/products/pro/integrations/open-api/code-samples/groups/)**: Tallyfy's Groups API lets you bundle members and guests into reusable groups that can be assigned to tasks and processes through standard create/list/get/update/delete operations scoped to your organization. Groups in Tallyfy organize members (user IDs) and guests (email addresses) so you can assign them to tasks and processes together. The API supports full CRUD -- create, list, get, update, and delete groups within your organization. All group endpoints are scoped to your organization at `https://go.tallyfy.com/api/organizations/{org_id}/groups`. You'll need the `manage_groups` permission to create, update, or delete groups, while listing and viewing are available to any authenticated org member. See the individual pages below for request details and code examples. - **[Managing members (users)](https://tallyfy.com/products/pro/integrations/open-api/code-samples/members/)**: Tallyfy's API lets you manage organization members through `/users` endpoints to invite, list, retrieve, update, remove users, and change their roles. Members are registered users in your Tallyfy organization. The API refers to them as "users" -- so all endpoints use `/users` in the path, not `/members`. You can invite, list, retrieve, update, remove members, and change their roles. You'll find request details and code samples on each page below. - **[Managing processes (runs)](https://tallyfy.com/products/pro/integrations/open-api/code-samples/processes/)**: Use the Tallyfy API to manage processes (runs) through org-scoped endpoints. Launch, list, update, archive, restore, and delete processes, plus retrieve activity feeds. Processes are called "runs" in the Tallyfy API. Each process is a live, trackable instance launched from a template. These endpoints let you manage the full lifecycle - from launching a new process through to archiving or permanently deleting it. All process endpoints are org-scoped under `/organizations/{org_id}/runs/...`. Here's what you can do: - **Launch a process** (`POST .../runs`) - Start a new process from a template, with optional kick-off form data and assignment overrides. - **List processes** (`GET .../runs`) - Retrieve processes filtered by status, owner, template, tags, and more. - **Get a process** (`GET .../runs/{run_id}`) - Fetch full details for a single process, including tasks and form fields. - **Update a process** (`PUT .../runs/{run_id}`) - Change name, summary, owner, tags, or folders on a running process. - **Archive a process** (`DELETE .../runs/{run_id}`) - Soft-delete a process. It disappears from default views but keeps all data intact. - **Activate (restore) a process** (`PUT .../runs/{run_id}/activate`) - Bring an archived process back to its previous active state. - **Permanently delete a process** (`DELETE .../runs/{run_id}/delete`) - Irreversibly remove an archived process and all its data. Admin-only, and the process must be archived first. - **Get activity feed** (`GET .../activity-feeds`) - Pull the audit trail of task completions, comments, and status changes for a process. - **Launch a project (no template)** (`POST .../runs`) - Create an empty process container for ad-hoc tasks without a predefined template. Each page below has request details and code samples in multiple languages. - **[Managing templates (blueprints)](https://tallyfy.com/products/pro/integrations/open-api/code-samples/templates/)**: Tallyfy's API lets you manage process templates with standard CRUD operations. The API uses "Checklists" in endpoint paths and "Blueprints" in some method names instead of "Templates" shown in the UI. ## Templates in the API Tallyfy process templates define the structure of your repeatable processes. In the UI, they're called **Templates** - but the API uses the term **Checklists** in endpoint paths (e.g., `/checklists`) and occasionally **Blueprints** in certain method names. :::note[Terminology difference] **UI**: Templates **API**: Checklists (endpoint paths) / Blueprints (some method names) Keep this in mind when building against the API. ::: You can create, retrieve, update, publish, export, and delete templates through the API. Check the individual pages below for request details and code examples. - **[Managing tasks](https://tallyfy.com/products/pro/integrations/open-api/code-samples/tasks/)**: Tallyfy's API gives you full control over tasks, whether they live inside a running process or exist as standalone one-off items. List, retrieve, create, update, complete, and reopen them programmatically. Tasks are individual work items in Tallyfy. They're either steps within a running process or standalone one-off tasks. The API lets you list, get, create, update, complete, and reopen them. See the pages below for request details and code examples. - **[Managing tags](https://tallyfy.com/products/pro/integrations/open-api/code-samples/tags/)**: Tallyfy's Tags API allows you to create and manage organization-scoped labels with unique titles (up to 30 characters) and optional hex colors that can be applied to templates and processes through standard CRUD endpoints with optional usage statistics. Tags let you label and filter templates, processes, tasks, and steps across your organization. Every endpoint is org-scoped under `/organizations/{org_id}/tags`. ## Available endpoints | Operation | Method | Path | Response | |-----------|--------|------|----------| | List tags | `GET` | `/organizations/{org_id}/tags` | 200 with paginated array | | Create tag | `POST` | `/organizations/{org_id}/tags` | 201 with created tag | | Get tag | `GET` | `/organizations/{org_id}/tags/{tag_id}` | 200 with tag object | | Update tag | `PUT` | `/organizations/{org_id}/tags/{tag_id}` | 200 with updated tag | | Delete tag | `DELETE` | `/organizations/{org_id}/tags/{tag_id}` | 204 No Content | ## Key facts - **title** is required, must be unique within the org, and is capped at 30 characters. - **color** is optional and must be exactly 7 characters (a `#` hex value like `#ff5733`). - Deleting a tag is permanent -- the API uses a hard delete, so deleted tags can't be recovered. - Add `?with=statistics` to any GET request to include usage counts (active/archived templates and processes). - The response object returns: `id`, `title`, `color`, `auto_generated`, `created_at`, and `deleted_at`. See each child page below for request details and code samples in multiple languages. ### Files - **[Delete file](https://tallyfy.com/products/pro/integrations/open-api/code-samples/files/delete-file/)**: Tallyfy's API lets you permanently delete an uploaded file and its storage record by sending a DELETE request to the /file/ endpoint. Organization logos can't be deleted, and the alternative /assets/ endpoint only archives without removing the actual stored file. ## Endpoint `DELETE /organizations/{org_id}/file/{asset_id}` This endpoint permanently deletes an uploaded file (asset) in Tallyfy. It removes both the asset record and the underlying file from storage. :::note[Alternative endpoint] A separate endpoint `DELETE /organizations/{org_id}/assets/{asset_id}` also exists but only archives the asset record -- it doesn't delete the file from storage. Use the `/file/` endpoint above for full deletion. ::: :::caution[Restrictions] Organization logos can't be deleted through this endpoint. Attempting to delete a logo returns an error. ::: ## Request Replace `{org_id}` with your Organization ID and `{asset_id}` with the Asset ID of the file you want to delete. ### Headers | Header | Value | Required | |--------|-------|----------| | `Authorization` | `Bearer {your_access_token}` | Yes | | `Accept` | `application/json` | Yes | | `X-Tallyfy-Client` | `APIClient` | Yes | ### Body You don't need a request body. ### Code samples ## Response A successful request returns a `200 OK` status code with an empty response body, confirming the file has been deleted from both the Tallyfy record and storage. - **[Download file](https://tallyfy.com/products/pro/integrations/open-api/code-samples/files/download-file/)**: Tallyfy's API provides two GET endpoints for retrieving uploaded files: one that returns the file inline with its original MIME type for browser display and another with a `/dl` suffix that forces a download as an attachment with the original filename preserved in the Content-Disposition header. ## Endpoints - `GET /organizations/{org_id}/file/{file_id}` - View the file inline (returns the file's actual MIME type). - `GET /organizations/{org_id}/file/{file_id}/dl` - Download the file as an attachment (always returns `application/octet-stream`). Both endpoints return raw file content for an asset that's been uploaded to Tallyfy. Use the `/dl` suffix when you want to force a download with a `Content-Disposition: attachment` header. ## Request Replace `{org_id}` with your organization ID and `{file_id}` with the asset ID of the file. You'll get this ID when uploading the file or from task/process data. ### Headers - `Authorization: Bearer {your_access_token}` - `X-Tallyfy-Client: APIClient` ### Code samples (download as attachment) These samples fetch the file from the `/dl` endpoint and save it locally. ### Viewing inline To display the file inline (when the browser supports the MIME type), use the endpoint without `/dl`. This returns the file's original `Content-Type` instead of `application/octet-stream`: ```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 `200 OK`. The response body is the raw file content -- not JSON. **Download endpoint** (`/dl`) headers: - `Content-Type: application/octet-stream` - `Content-Disposition: attachment; filename=""` - `Content-Length: ` **Inline endpoint** (without `/dl`) headers: - `Content-Type: ` (e.g., `image/png`, `application/pdf`) - `Content-Length: ` If the file ID is invalid or you don't have access, the API returns `404` or `403` with an error message. --- - **[Get file metadata](https://tallyfy.com/products/pro/integrations/open-api/code-samples/files/get-file-metadata/)**: Tallyfy's API lets you retrieve metadata for any uploaded file (asset) by calling GET on the asset endpoint with your organization and asset IDs. It returns details like the filename, upload date, and which process or task the file is attached to. ## Endpoint `GET /organizations/{org_id}/assets/{asset_id}` This endpoint retrieves metadata for a specific uploaded file (called an "asset" in Tallyfy's API). It returns details like the filename, upload date, and which object the file is attached to. ## Request Replace `{org_id}` with your Organization ID and `{asset_id}` with the asset ID of the file you want metadata for. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Code samples ## Response A successful request returns a `200 OK` status and a JSON object with the asset metadata inside a `data` property. ```json { "data": { "id": "ASSET_ID_TO_GET_METADATA", "filename": "report_q1.pdf", "version": 1, "uploaded_from": "capture_id_abc123", "uploaded_at": "2024-03-15T10:30:00Z", "step_id": "step_id_xyz789", "source": "local", "system": null, "uploaded_to_s3": true, "subject": { "id": "run_id_or_checklist_id", "type": "Run" } } } ``` Key fields in the response: | Field | Description | |-------|-------------| | `id` | Unique asset identifier | | `filename` | Original filename of the uploaded file | | `version` | Version number of the asset | | `uploaded_from` | Form field ID the file was uploaded from, or `ko_field` for kick-off fields | | `uploaded_at` | Timestamp when the file was uploaded | | `step_id` | Step ID if the file is attached to a task step (can be null) | | `source` | Upload source - defaults to `local` | | `system` | External storage system if applicable (e.g., Dropbox, Google Drive) | | `uploaded_to_s3` | Whether the file was stored in S3 | | `subject` | Object containing the parent's `id` and `type` (e.g., Run, Checklist, Organization) | If the asset ID isn't found or you don't have permission, you'll get a `404` or `403` error. --- - **[Upload & attach file](https://tallyfy.com/products/pro/integrations/open-api/code-samples/files/upload-attach-file/)**: Tallyfy''s API uses a two-step process to attach files to form fields. First upload the file via a multipart POST to the `/file` endpoint to get an asset object, then PUT that object to link the file to a task or kick-off form field. Attaching files to form fields via Tallyfy's API is a two-step process: 1. **Upload the file** - send the file to Tallyfy's upload endpoint and get back an asset object. 2. **Attach to the field** - use that asset object to update the task or template, linking the file to the right form field. ## Step 1 - Upload the file ### Endpoint `POST /organizations/{org_id}/file` Both `/file` and `/assets` route to the same handler, but `/file` is the standard endpoint for uploads. ### Request type `multipart/form-data` ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` Don't set `Content-Type` manually - your HTTP client sets it automatically for multipart requests. ### Form data fields | Field | Required | Description | Example | |---|---|---|---| | `name` | Yes | The file binary data (max 100MB) | *(file input)* | | `subject_id` | Yes | ID of the parent object - `run_id` for tasks, `checklist_id` for kick-off | `run_abc123` | | `subject_type` | Yes | `Run` for task fields, `Checklist` for kick-off fields | `Run` | | `uploaded_from` | Yes | The form field's Capture ID for tasks, or `ko_field` for kick-off fields | `capture_id_abc123` | | `source` | No | How the file is provided - `local` or `url` | `local` | | `step_id` | No | Step ID within the template (only for task uploads) | `step_xyz789` | | `checklist_id` | No | Template ID the process was launched from (only for task uploads) | `template_efg456` | | `system` | No | External storage system if applicable | `Dropbox`, `Google Drive`, etc. | ### Allowed file types The API accepts these extensions: `xlsx`, `xls`, `pptx`, `docx`, `ppt`, `doc`, `rtf`, `pdf`, `txt`, `mpga`, `mov`, `qt`, `mp4`, `webm`, `jpg`, `jpeg`, `gif`, `png`, `ai`, `psd`, `zip`, `xml`, `xps`, `dwg`, `csv`, `tif`, `bmp`. :::tip[Finding IDs] You can find form field IDs (Capture IDs), step IDs, run IDs, and checklist IDs by calling the `GET` endpoints for tasks, processes, or templates with the `with` parameter (e.g., `with=step,form_fields`). ::: ### Code samples for upload ### Upload response A successful upload returns `200 OK` with the asset object wrapped in `data`. You'll need this object for Step 2. ```json { "data": { "id": "asset_id_abc123xyz", "filename": "document.pdf", "version": 1, "uploaded_from": "capture_id_abc123", "uploaded_at": "2024-01-15T10:00:00Z", "step_id": "step_id_xyz789", "source": "local", "system": null, "uploaded_to_s3": true, "subject": { "id": "run_id_abc", "type": "Run" } } } ``` ## Step 2 - Attach the uploaded file to a field Use the asset object from Step 1 to update the task or template, linking the file to the form field. ### Endpoint - **Task field:** `PUT /organizations/{org_id}/runs/{run_id}/tasks/{task_id}` - **Kick-off field:** `PUT /organizations/{org_id}/checklists/{checklist_id}` ### Request type `application/json` ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` - `Content-Type: application/json` ### Body for task fields The `taskdata` object uses the form field's Capture ID as the key. The value is 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, "uploaded_from": "capture_id_abc123", "uploaded_at": "2024-01-15T10:00:00Z", "step_id": "step_id_xyz789", "source": "local", "uploaded_to_s3": true, "subject": { "id": "run_id_abc", "type": "Run" } } ] } } ``` ### Body for kick-off fields Update the template's `prerun` array. Set the `value` for your file field to an **array containing the asset object** from Step 1. ```json { "prerun": [ { "id": "PRERUN_FIELD_ID_FOR_FILE", "value": [ { "id": "asset_id_abc123xyz", "filename": "document.pdf", "version": 1, "uploaded_from": "ko_field", "uploaded_at": "2024-01-15T10:00:00Z", "source": "local", "uploaded_to_s3": true, "subject": { "id": "checklist_id_abc", "type": "Checklist" } } ] } ] } ``` :::caution[Don't lose existing prerun fields] When updating kick-off fields, you need to send the **entire** `prerun` array with all fields. If you only send the file field, other kick-off fields may get removed. Fetch the template first with `GET /organizations/{org_id}/checklists/{checklist_id}` to get the current structure. ::: ### Code samples for attaching These examples assume you have the `assetObject` from Step 1 and the required IDs. ### Attach response A successful `PUT` returns `200 OK` with the updated task or template object. The file attachment appears under the field's Capture ID in `taskdata`. ```json { "data": { "taskdata": { "CAPTURE_ID_OF_FILE_FIELD": [ { "id": "asset_id_abc123xyz", "filename": "document.pdf", "version": 1, "uploaded_from": "capture_id_abc123", "uploaded_at": "2024-01-15T10:00:00Z", "step_id": "step_id_xyz789", "source": "local", "uploaded_to_s3": true, "subject": { "id": "run_id_abc", "type": "Run" } } ] } } } ``` :::note[Common mistakes] - **Upload doesn't attach automatically.** You must complete Step 2 to link the file to a form field. - **Send the full asset object.** Place the complete object from `response.data` inside the array for the file field in `taskdata`. - **Task uploads need these fields:** `uploaded_from` = Capture ID, `subject_type` = `Run`, `subject_id` = run ID, plus `checklist_id` and `step_id`. - **Kick-off uploads need these fields:** `uploaded_from` = `ko_field`, `subject_type` = `Checklist`, `subject_id` = checklist ID. - **Download URLs:** To download a file, use `GET /organizations/{org_id}/file/{file_id}/dl`. To view inline, use `GET /organizations/{org_id}/file/{file_id}`. ::: --- ### Authentication - **[Get & use a personal access token](https://tallyfy.com/products/pro/integrations/open-api/code-samples/authentication/personal-access-token/)**: Authenticate with Tallyfy's API using a personal access token from Settings > Integrations > REST API. Send it as a Bearer token with Accept and X-Tallyfy-Client headers on every request. Tokens expire after six months or when you log out. The quickest 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. No OAuth flow required for basic usage. ## Getting your token 1. Log in to your Tallyfy account at [https://go.tallyfy.com/](https://go.tallyfy.com/). 2. Navigate to **Settings** > **Integrations** > **REST API**. 3. Copy your personal `access_token` and store it securely. Personal access tokens expire after **6 months** from the time they're issued. :::caution[Keep your token secure] Treat your personal access token like a password. Don't share it publicly or commit it to version control. Anyone with your token can access your Tallyfy data. ::: :::warning[Token invalidation on logout] Your personal access token is deleted when you log out of the Tallyfy web interface. This means any integrations using that token will stop working and return `401` errors. **To keep integrations stable** - create a dedicated user account for API access that doesn't log out. For production systems, consider the [OAuth client credentials flow](/products/pro/integrations/open-api/code-samples/authentication/client-credentials-flow/) instead, which issues tokens independently of user sessions. ::: :::note[API access plans] API access with personal tokens is available on paid Tallyfy plans. If you're on a trial or free plan, contact Tallyfy Support to request access. ::: ## Using your token in API requests Include these three headers with every request: - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` (required - you'll get `401` errors without it) Here's how to set these headers in different languages: Replace `YOUR_PERSONAL_ACCESS_TOKEN` and `YOUR_ORGANIZATION_ID` with your actual values before running any of these examples. --- - **[Use the client credentials flow](https://tallyfy.com/products/pro/integrations/open-api/code-samples/authentication/client-credentials-flow/)**: Tallyfy's OAuth 2.0 client credentials flow lets backend services authenticate without user login. Obtain a Client ID and Client Secret from Tallyfy Support, then exchange them for application-level tokens (valid 7 days) or user-specific tokens (valid 3 months) to call the API. ## Client credentials authentication for server apps The OAuth 2.0 client credentials flow handles machine-to-machine authentication. It's designed for backend services and third-party apps that interact with the Tallyfy API without a user logging in. You'll need a `Client ID` and `Client Secret` from Tallyfy Support before you start. :::caution[Enterprise feature - setup required] Client credentials are only available to paid Tallyfy organizations and require manual setup by Tallyfy Support. They aren't accessible during free trials. Contact support to request access and describe your integration use case. ::: ## How the flow works [Diagram removed for brevity] ### What to notice - **Step 1 is manual** - contacting Tallyfy Support for credentials is a one-time setup you can't automate - **Two token types** - application tokens (system operations) and user-specific tokens (acting as a particular user) - **Different lifetimes** - application tokens expire in 7 days (604,800 seconds), user-specific tokens expire in 3 months (7,776,000 seconds) ### When to use this This pattern works well when you want to: - Embed Tallyfy functionality inside your own software - Automate process management or user provisioning - Build system-level integrations (reporting, data sync) - Provide workflow features to your users without separate Tallyfy logins ### Steps #### 1. Request client credentials Contact Tallyfy Support with your integration use case. They'll provide a `Client ID` and `Client Secret` for your organization. Store these securely. #### 2. Get an application access token Your app first needs its own access token for operations like user provisioning or generating user-specific tokens. - **Endpoint:** `POST https://go.tallyfy.com/oauth/token` - **Content-Type:** `application/x-www-form-urlencoded` - **Parameters:** - `grant_type`: `client_credentials` - `client_id`: Your Client ID - `client_secret`: Your Client Secret - `scope`: `*` (optional) **Response:** ```json { "token_type": "Bearer", "expires_in": 604800, "access_token": "eyJ0eXAiOiJKV1Q..." } ``` :::note[Token expiration] Application tokens are valid for 7 days (604,800 seconds). Request a new one before it expires by repeating the same POST request - there's no separate refresh token flow for client credentials. ::: ### 3. Provision users (optional) With your application 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}` - `Content-Type: application/json` - `X-Tallyfy-Client: APIClient` - **Body fields:** - `first_name` (required): Max 32 characters - `last_name` (required): Max 32 characters - `email` (required): Must be unique, valid domain - `role` (optional): `admin`, `standard`, or `light` - `timezone` (optional): User's timezone string ### 4. Get user-specific tokens (optional) To act as a specific user, generate a user-scoped token with your application token. - **Endpoint:** `POST https://go.tallyfy.com/api/applications/{orgID}/users/{email}/token` - **Headers:** - `Authorization: Bearer {your_app_access_token}` - `X-Tallyfy-Client: APIClient` - **Note:** No request body needed - the user's email goes in the URL path. **Response:** ```json { "token_type": "Bearer", "expires_in": 7776000, "access_token": "eyJ0eXAiOiJKV1Q..." } ``` :::note[User token lifetime] User-specific tokens are valid for 3 months (7,776,000 seconds). The user must already exist in your organization. ::: ### 5. Make API requests Use your token (application-level or user-specific) in API calls with these required headers: - `Authorization: Bearer {token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` All API endpoints follow the pattern `https://go.tallyfy.com/api/organizations/{orgID}/...` For code examples of specific API operations, see the [personal access token](/products/pro/integrations/open-api/code-samples/authentication/personal-access-token/) guide - the request format is identical, just swap in your token. ### Security best practices - Store client credentials in encrypted secrets management (never in source code) - Protect both application-level and user-specific tokens - Rotate secrets periodically - Use HTTPS for all requests - Re-request application tokens before the 7-day expiry --- ### Guests - **[Create guest](https://tallyfy.com/products/pro/integrations/open-api/code-samples/guests/create-guest/)**: Tallyfy's API lets you add external guests to your organization via a POST request with just an email address and optional profile fields. It automatically links existing global guests instead of creating duplicates. ## Endpoint `POST /organizations/{org_id}/guests` Creates a new guest in your organization. If the email already exists as a guest globally, Tallyfy doesn't create a duplicate. It adds that guest to your organization instead. ## 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) | Field | Type | Required | Description | |-------|------|----------|-------------| | `email` | string | Yes | Guest's email address. Must pass RFC/DNS validation and can't belong to an existing org member. | | `first_name` | string | No | Max 200 characters. | | `last_name` | string | No | Max 200 characters. | | `phone_1` | string | No | Max 20 characters. | | `phone_2` | string | No | Max 20 characters. | | `company_name` | string | No | Max 200 characters. | | `company_url` | string | No | Must be a valid URL. | | `contact_url` | string | No | Must be a valid URL. | | `image_url` | string | No | Must be a valid URL. | | `opportunity_url` | string | No | Must be a valid URL. | | `opportunity_name` | string | No | Max 200 characters. | | `timezone` | string | No | E.g., `America/Chicago`. | | `status` | string | No | Max 200 characters. | | `external_sync_source` | string | No | Only `salesforce` is accepted. | | `external_date_creation` | string | No | Format: `Y-m-d H:i:s`. | **Minimal example:** ```json { "email": "new.guest@contractor.com" } ``` **Fuller example:** ```json { "email": "client.contact@acme.com", "first_name": "Client", "last_name": "Contact", "company_name": "ACME Corp", "phone_1": "+1-212-555-0123" } ``` ### Code samples ## Response A successful request returns a `201 Created` status and a JSON object with the new guest's data. ```json { "data": { "id": 4523, "email": "external.partner@partnerco.com", "last_accessed_at": null, "last_known_ip": null, "last_known_country": null, "first_name": "External", "last_name": "Partner", "created_at": "2025-01-15 10:30:00", "deleted_at": null, "link": "https://go.tallyfy.com/...", "details": { "status": null, "phone_1": null, "phone_2": null, "timezone": null, "image_url": null, "contact_url": null, "company_url": null, "opportunity_url": null, "company_name": "Partner Co", "opportunity_name": null, "external_sync_source": null, "external_date_creation": null, "cadence_days": null, "associated_members": null, "last_city": null, "last_country": null, "last_accessed_at": null, "disabled_at": null, "disabled_by": null, "reactivated_at": null, "reactivated_by": null } } } ``` If the email belongs to an existing org member, you'll get a `422 Unprocessable Entity` error. If the email already exists as a guest globally, Tallyfy adds them to your organization rather than creating a duplicate. --- - **[Delete guest](https://tallyfy.com/products/pro/integrations/open-api/code-samples/guests/delete-guest/)**: Tallyfy's DELETE endpoint at `/organizations/{org_id}/guests/{guest_email}` removes a guest by URL-encoded email. It detaches them from all tasks and soft-deletes the record if they don't belong to other organizations. ## Endpoint `DELETE /organizations/{org_id}/guests/{guest_email}` This endpoint removes a guest from your Tallyfy organization by email address. It detaches the guest from all tasks, removes the org association, and soft-deletes the guest record if they don't belong to any other organizations. ## 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 You don't need a request body. ### Code samples ## Response A successful request returns a `200 OK` status with the deleted guest's details wrapped in a `data` object. The guest is detached from all tasks and removed from the organization. If the guest doesn't belong to any other organizations, the record is soft-deleted. If the email isn't found, you'll get a `422` validation error since the email must exist in the guests table. --- - **[Get guest](https://tallyfy.com/products/pro/integrations/open-api/code-samples/guests/get-guest/)**: Retrieve a specific guest's details by making a GET request to `/organizations/{org_id}/guests/{guest_email}` with a URL-encoded email. You can also include completion statistics with the `with=stats` query parameter. {/* ACCURACY_CHECK: Response section says 201 Created for a GET endpoint, but GET requests typically return 200 OK. The code samples check for both 200 and 201. */} ## Endpoint `GET /organizations/{org_id}/guests/{guest_email}` This endpoint retrieves details for a specific guest, 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 (e.g., `user%40example.com`). ### Headers | Header | Value | Required | |--------|-------|----------| | `Authorization` | `Bearer {your_access_token}` | Yes | | `Accept` | `application/json` | Yes | | `X-Tallyfy-Client` | `APIClient` | Yes | ### Query parameters (optional) | Parameter | Type | Description | |-----------|------|-------------| | `with` | string | Include extra data. Use `stats` for guest completion statistics. | ### Code samples ## Response A successful request returns a `201 Created` status code. You'll get a JSON object with a `data` property containing the guest's details. ```json { "data": { "id": 1234, "email": "guest.to.get@example.com", "last_accessed_at": "2025-05-15T10:00:00Z", "last_known_ip": "192.168.1.1", "last_known_country": "US", "details": { "status": "active", "phone_1": "+1234567890", "phone_2": null, "timezone": "America/New_York", "image_url": null, "contact_url": null, "company_url": "https://example.com", "opportunity_url": null, "company_name": "Guest Company", "opportunity_name": null, "external_sync_source": null, "external_date_creation": null, "cadence_days": null, "associated_members": null, "last_city": "New York", "last_country": "US", "last_accessed_at": "2025-05-15T10:00:00Z", "disabled_at": null, "disabled_by": null, "reactivated_at": null, "reactivated_by": null }, "first_name": "Specific", "last_name": "Guest", "created_at": "2025-01-10T08:30:00Z", "deleted_at": null, "link": "https://go.tallyfy.com/...", "stats": {} } } ``` If the guest email isn't found or you lack permission, you'll get a `404 Not Found` or `403 Forbidden` error. --- - **[Update guest](https://tallyfy.com/products/pro/integrations/open-api/code-samples/guests/update-guest/)**: Tallyfy's PUT endpoint at `/organizations/{org_id}/guests/{guest_email}` updates the `associated_members` field for an existing guest. Send an array of member IDs to get back the full guest record with a 201 status. ## Endpoint `PUT /organizations/{org_id}/guests/{guest_email}` Updates the `associated_members` for an existing guest in your 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. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` - `Content-Type: application/json` ### Body (JSON) | Field | Type | Required | Description | |-------|------|----------|-------------| | `associated_members` | array of integers | No | Array of organization member IDs to associate with this guest. Replaces the current list. | :::note[Limited updatable fields] This endpoint only updates the `associated_members` field on the organization-guest relationship. Fields like `first_name`, `last_name`, `company_name`, and `phone_1` aren't updatable through this endpoint -- set those when creating the guest instead. ::: **Example body:** ```json { "associated_members": [1234, 5678] } ``` :::note You can't change a guest's email address through this endpoint. To change a guest's email, delete the old guest record and create a new one. ::: ### Code samples ## Response A successful request returns a `201 Created` status and a JSON object with the full guest record after the update. ```json { "data": { "id": 1234, "email": "guest.to.update@example.com", "last_accessed_at": "2024-06-15T10:30:00Z", "last_known_ip": "203.0.113.42", "last_known_country": "US", "details": { "status": "active", "phone_1": "+15551234567", "phone_2": null, "timezone": "America/Chicago", "image_url": null, "contact_url": null, "company_url": null, "opportunity_url": null, "company_name": "Acme Corp", "opportunity_name": null, "external_sync_source": null, "external_date_creation": null, "cadence_days": null, "associated_members": [1234, 5678], "last_city": "Chicago", "last_country": "US", "last_accessed_at": "2024-06-15T10:30:00Z", "disabled_at": null, "disabled_by": null, "reactivated_at": null, "reactivated_by": null }, "first_name": "Jane", "last_name": "Doe", "created_at": "2024-01-10T09:00:00Z", "deleted_at": null, "link": "https://go.tallyfy.com/..." } } ``` If the guest email isn't found, you'll get a `404` error. Invalid payloads return `422`. --- - **[List guests](https://tallyfy.com/products/pro/integrations/open-api/code-samples/guests/list-guests/)**: Retrieve a paginated list of guest users in your organization. You'll get detailed profiles with access history, and you can filter by email or include completion statistics. ## Endpoint `GET /organizations/{org_id}/guests` Retrieves a paginated list of guest users in your 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) | Parameter | Type | Description | |-----------|------|-------------| | `q` | string | Search query to filter guests by email | | `sort` | string | Sort field (also accepts `sort_by`). Defaults to `created_at` | | `per_page` | integer | Results per page (defaults to `999`) | | `page` | integer | Page number | | `without_pagination` | boolean | Return all results without pagination | | `with` | string | Include extra data. Use `stats` for completion statistics | ### Code samples ## Response A successful request returns a `200 OK` status with a JSON object. There's a `data` array of guest objects and a `meta` object with pagination details. ```json { "data": [ { "id": 1234, "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": { "status": "active", "phone_1": null, "phone_2": null, "timezone": "America/Chicago", "image_url": null, "contact_url": null, "company_url": null, "opportunity_url": null, "company_name": "External Inc.", "opportunity_name": null, "external_sync_source": null, "external_date_creation": null, "cadence_days": null, "associated_members": null, "last_city": null, "last_country": "US", "last_accessed_at": "2025-05-15T10:00:00Z", "disabled_at": null, "disabled_by": null, "reactivated_at": null, "reactivated_by": null }, "first_name": "External", "last_name": "Collaborator", "created_at": "2025-01-10T08:30:00Z", "deleted_at": null, "link": "https://go.tallyfy.com/...", "stats": { "assigned_tasks": 2, "tasks_completed": 5, "last_task_completed_at": "2025-05-14T16:30:00Z", "one_off_tasks_completed": 1, "last_one_off_task_completed_at": "2025-04-20T12:00:00Z" } } ], "meta": { "pagination": { "total": 25, "count": 25, "per_page": 999, "current_page": 1, "total_pages": 1 } } } ``` The `stats` object won't appear unless you request `with=stats`. The `link` field contains the guest's forever-link URL for accessing their tasks. --- ### Groups - **[Create group](https://tallyfy.com/products/pro/integrations/open-api/code-samples/groups/create-group/)**: Create a new group in your Tallyfy organization via a POST request with a name, description, and optional member or guest lists. You'll get the new group's details including its ID. ## Endpoint `POST /organizations/{org_id}/groups` Creates a new group in your Tallyfy organization. ## Request Replace `{org_id}` with your actual Organization ID. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` - `Content-Type: application/json` ### Body (JSON) | Field | Type | Required | Description | |-------|------|----------|-------------| | `name` | string | Yes | Group name (max 200 chars, must be unique in the org) | | `description` | string | Yes | A description for the group | | `members` | array of integers | No | User IDs to add as members | | `guests` | array of strings | No | Email addresses for guests to add | **Example body:** ```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 `201 Created` status. The response JSON wraps the new group inside a `data` object. ```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": "2025-06-10T14:30:00.000Z", "last_updated": "2025-06-10T14:30:00.000Z" } } ``` Save the returned `id` -- you'll need it to get, update, or delete this group later. --- - **[Delete group](https://tallyfy.com/products/pro/integrations/open-api/code-samples/groups/delete-group/)**: Tallyfy's DELETE endpoint at /organizations/{org_id}/groups/{group_id} permanently removes a group without deleting its members or guests. Returns a 204 No Content status on success, with code samples in JavaScript, Python, Java, Go, C++, and C#. ## Endpoint `DELETE /organizations/{org_id}/groups/{group_id}` This endpoint permanently deletes a group from your Tallyfy organization. It doesn't 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 you want to delete. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Body You don't need a request body. ### Code samples ## Response A successful request returns a `204 No Content` status with an empty response body. This is a permanent (hard) deletion -- the group can't be recovered after deletion. - **[Get group](https://tallyfy.com/products/pro/integrations/open-api/code-samples/groups/get-group/)**: Fetch details of a specific group in your Tallyfy organization using a GET request. Returns the group's name, description, members, guests, and timestamps. ## Endpoint `GET /organizations/{org_id}/groups/{group_id}` This endpoint retrieves details for a specific group in your Tallyfy organization. ## Request You'll need to replace `{org_id}` with your Organization ID and `{group_id}` with the group's ID. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Query parameters (optional) | Parameter | Type | Description | |-----------|--------|------------------------------------------| | `with` | string | Include related data. Supported: `assets` (group logo). | ### Code samples ## Response You'll get a `200 OK` status with a JSON object containing the group's details in the `data` property. ### Response fields | Field | Type | Description | |----------------|----------|----------------------------------------------| | `id` | string | Unique identifier for the group | | `name` | string | Name of the group | | `description` | string | Description of the group | | `logo` | string | URL of the group's logo image | | `members` | array | List of member user IDs in this group | | `guests` | array | List of guest email addresses in this group | | `created_at` | string | Timestamp when the group was created | | `last_updated` | string | Timestamp when the group was last modified | If you include `with=assets`, there's also an `assets` property with logo file details. ### Example response ```json { "data": { "id": "group_id_here", "name": "Engineering Team", "description": "Core engineering group", "logo": null, "members": ["user_id_1", "user_id_2"], "guests": ["guest@example.com"], "created_at": "2024-01-15T10:30:00.000Z", "last_updated": "2024-06-20T14:45:00.000Z" } } ``` - **[Update group](https://tallyfy.com/products/pro/integrations/open-api/code-samples/groups/update-group/)**: Tallyfy's PUT endpoint for groups lets you rename a group or change its description and fully replace its member and guest lists by sending updated user IDs or email arrays to `/organizations/{org_id}/groups/{group_id}`. Includes code samples in JavaScript, Python, Java, Go, C++, and C#. ## Endpoint `PUT /organizations/{org_id}/groups/{group_id}` Updates a group's details or membership within your Tallyfy organization. You'll need `manage_groups` permission. ## Request Replace `{org_id}` with your Organization ID and `{group_id}` with the ID of the group to update. ### Headers | Header | Value | Required | |--------|-------|----------| | Authorization | Bearer `{your_access_token}` | Yes | | Accept | application/json | Yes | | X-Tallyfy-Client | APIClient | Yes | | Content-Type | application/json | Yes | ### Body (JSON) | Field | Type | Required | Description | |-------|------|----------|-------------| | `name` | string | No | New name (max 200 characters, must be unique per org) | | `description` | string | Yes | Group description | | `members` | array of integers | No | **Replaces** the entire member list with these user IDs | | `guests` | array of strings | No | **Replaces** the entire guest list with these emails | :::caution[Membership updates replace] Providing the `members` or `guests` arrays replaces the entire existing list for that type. To add or remove individuals incrementally, first GET the current group details, modify the list in your code, then send the complete new list in the PUT request. ::: ### Code samples ## Response A successful request returns a `201 Created` status and a JSON object containing the full group details after the update, wrapped in a `data` object. ```json { "data": { "id": "GROUP_ID_TO_UPDATE", "name": "Project Alpha Core Team", "description": "Updated team description.", "logo": null, "members": [1001, 1008, 1010], "guests": [], "created_at": "2025-01-15T10:30:00.000000Z", "last_updated": "2025-06-20T14:22:00.000000Z" } } ``` If the group ID isn't found, you don't have permission, or the request body is invalid, expect a `404`, `403`, `400`, or `422` error. --- - **[List groups](https://tallyfy.com/products/pro/integrations/open-api/code-samples/groups/list-groups/)**: Retrieve a paginated list of all groups in your Tallyfy organization. Filter by name, sort results, and include related assets or users in the response. ## Endpoint `GET /organizations/{org_id}/groups` This endpoint retrieves a paginated list of groups in your Tallyfy organization. ## 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) | Parameter | Type | Description | | --- | --- | --- | | `q` | string | Search groups by name or description | | `per_page` | integer | Results per page (default `10`, max `100`) | | `page` | integer | Page number (default `1`) | | `sort_by` | string | Sort field - `name`, `created_at` (default), or `updated_at` | | `with` | string | Include related data - `assets`, `users`, or `guests` | ### Code samples ## Response You'll get a `200 OK` status code and a JSON object with a `data` array of groups and a `meta` object for pagination. ```json { "data": [ { "id": "group_id_abc123", "name": "Sales Team", "description": "Handles all sales inquiries.", "logo": null, "members": [1001, 1005], "guests": ["client.a@example.com"], "created_at": "2023-01-15T09:00:00Z", "last_updated": "2023-06-20T10:00:00Z" } ], "meta": { "pagination": { "total": 15, "count": 10, "per_page": 10, "current_page": 1, "total_pages": 2, "links": {} } } } ``` --- ### Members - **[Get member](https://tallyfy.com/products/pro/integrations/open-api/code-samples/members/get-member/)**: Tallyfy's API lets admin users fetch a specific organization member's profile by their numeric user ID through a GET request. You can optionally include related data like stats, groups, and preferences. ## Endpoint `GET /organizations/{org_id}/users/{user_id}` This endpoint retrieves the profile of a specific member in your Tallyfy organization by their numeric user ID. It requires **admin** privileges. ## Request Replace `{org_id}` with your Organization ID and `{user_id}` with the integer ID of the member. ### 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. Options are `stats`, `assets`, `groups`, `organizations`, `preferences`, `member_watchers`, `guest_watchers`, `auth_methods`, `country`. ### Code samples ## Response A successful request returns a `200 OK` status code and a JSON object with a `data` property containing the 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", "country_id": 1, "is_active": true, "last_login_at": "2025-01-15T10:30:00+00:00", "activated_at": "2024-06-01T08:00:00+00:00", "type": "standard", "created_at": "2024-06-01T08:00:00+00:00", "updated_at": "2025-01-15T10:30:00+00:00", "phone": "+1234567890", "job_title": "Project Manager", "timezone": "America/Los_Angeles", "UTC_offset": "-08:00", "role": "Standard", "status": "active", "date_format": "MM/DD/YYYY", "is_default_admin": false, // ... other profile fields ... // Included with 'with=stats': "stats": { "data": { "steps_created": 42, "tasks_completed": 120, "processes_launched": 15, "checklists_created": 8, "last_step_created_at": "2025-01-10T14:00:00+00:00" } }, // Included with 'with=groups': "groups": { "data": [ { "id": "group_id_3", "name": "Project Alpha", "logo": null, "members": [12345, 67890], "guests": ["guest@example.com"] } ] } } } ``` If the member ID isn't found, you'll get a `404 Not Found` error. If you don't have admin privileges, expect a `403 Forbidden` error. --- - **[Invite member](https://tallyfy.com/products/pro/integrations/open-api/code-samples/members/invite-member/)**: Invite new users to your Tallyfy organization by sending a POST request with their email, name, role, and a personal message. The response returns the invited user's profile with an invited status until they accept. ## Endpoint `POST /organizations/{org_id}/users/invite` This endpoint sends an invitation email to a new user, asking 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) | Field | Type | Required? | Description | |-------|------|-----------|-------------| | `email` | string | Yes | Email address of the person to invite. | | `first_name` | string | Yes | First name of the invitee (max 32 characters). | | `last_name` | string | Yes | Last name of the invitee (max 32 characters). | | `role` | string | Yes | Role to assign: `admin`, `standard`, or `light`. | | `message` | string | Yes | Personal message included in the invitation email (max 5000 characters). | > Non-admin users can't assign the `admin` role. The organization must also allow non-admin users to send invites, or the request won't work. **Example body:** ```json { "email": "new.user@example.com", "first_name": "Charlie", "last_name": "Brown", "role": "standard", "message": "Welcome to the team! Looking forward to working with you." } ``` ## Code samples ## Response A successful request returns a `200 OK` status. The response body contains the invited user's profile wrapped in a `data` object, with a status of `invited` until they accept. ```json { "data": { "id": 1005, "email": "charlie.brown@example.com", "username": null, "first_name": "Charlie", "last_name": "Brown", "full_name": "Charlie Brown", "profile_pic": null, "country_id": 1, "is_active": false, "last_login_at": null, "activated_at": null, "type": null, "created_at": "2025-01-15T10:00:00Z", "updated_at": "2025-01-15T10:00:00Z", "timezone": "America/New_York", "UTC_offset": "-05:00", "status": "invited", "role": "standard", "invited_by": 501, "approved_at": "2025-01-15T10:00:00Z" } } ``` If the email already belongs to an existing member, you'll get a `422 Unprocessable Entity` error. --- - **[List members](https://tallyfy.com/products/pro/integrations/open-api/code-samples/members/list-members/)**: Tallyfy's API lets you retrieve a paginated list of organization members via a GET request. Filter by name or email, sort results, and include related data like groups and stats. ## Endpoint `GET /organizations/{org_id}/users` This endpoint returns a paginated list of members (users) in your Tallyfy organization. ## 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) - `with` (string): Comma-separated list of related data to include. Supported values include `groups`, `stats`, `organizations`, `preferences`, `assets`, `member_watchers`, `guest_watchers`, `auth_methods`, `country`. - `q` (string): Search query to filter members by first name, last name, or email. - `sort` (string): Field to sort by. Prefix with `-` for descending order (e.g., `-created_at`). - `per_page` (integer): Number of results per page. Defaults to `9999` if you don't specify one. - `page` (integer): Page number for paginated results. ### Code samples ## Response You'll get a `200 OK` status code and a JSON object with a `data` array of member objects, plus a `meta` object with pagination details. ```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", "country_id": 1, "is_active": true, "last_login_at": "2025-01-15T10:30:00+00:00", "activated_at": "2024-06-01T08:00:00+00:00", "type": "standard", "created_at": "2024-06-01T08:00:00+00:00", "updated_at": "2025-01-15T10:30:00+00:00", "phone": "+1234567890", "job_title": "Project Manager", "timezone": "America/New_York", "UTC_offset": "-05:00", "role": "Admin", "status": "active", "date_format": "MM/DD/YYYY", "is_default_admin": false, "groups": { "data": [ { "id": "group_id_1", "name": "Sales Team", "logo": null, "members": [1001, 1002], "guests": [] } ] } }, { "id": 1002, "email": "bob@example.com", "first_name": "Bob", "last_name": "Jones", "status": "active", "role": "Standard" } ], "meta": { "pagination": { "total": 2, "count": 2, "per_page": 50, "current_page": 1, "total_pages": 1 } } } ``` --- - **[Remove member](https://tallyfy.com/products/pro/integrations/open-api/code-samples/members/remove-member/)**: Tallyfy's API lets you deactivate a member from your organization using a DELETE request with optional task reassignment. It also supports a separate two-step flow for permanent deletion that requires disabling the member first. ## Removing a member via API `DELETE /organizations/{org_id}/users/{user_id}` This endpoint deactivates a member from your Tallyfy organization. The member loses access to this org, but their global Tallyfy account stays intact. You can optionally reassign their tasks to another member during removal. You'll need admin permissions. Bot users can't be removed through this endpoint. ### Separate permanent deletion flow Tallyfy also offers a two-step permanent deletion flow using different endpoints: 1. **Disable**: `DELETE /organizations/{org_id}/users/{user_id}/disable` 2. **Permanently delete**: `DELETE /organizations/{org_id}/users/{user_id}/delete` The permanent delete endpoint requires the member to be disabled first -- you'll get an error if you skip that step. The main `DELETE /organizations/{org_id}/users/{user_id}` endpoint documented here doesn't require disabling first. ## Request Replace `{org_id}` with your Organization ID and `{user_id}` with the member's numeric ID. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Query parameters (optional) - `with_reassignment` (boolean) - Set to `true` to reassign the member's tasks before removal. - `to` (integer) - Required when `with_reassignment=true`. The user ID receiving reassigned tasks. Example: `?with_reassignment=true&to=1002` ### Body No request body needed. ### Code samples ## Response Returns `200 OK` with the removed member's data wrapped in a `data` object. ### Success response example ```json { "data": { "id": 12345, "email": "john.doe@example.com", "first_name": "John", "last_name": "Doe", "role": "standard", "status": "disabled" } } ``` ### Error responses | Status | Error message | What to do | |--------|--------------|------------| | 400 | `You can't remove a bot user from this organization!` | Bot users can't be removed through this endpoint. | | 400 | `Cannot modify the default administrator. Please assign another member as default administrator first.` | Assign the default admin role to someone else before removing this member. | | 404 | User not found | Check that the user ID exists in this organization. | - **[Update member role](https://tallyfy.com/products/pro/integrations/open-api/code-samples/members/update-member-role/)**: Tallyfy's API lets you change any member's role to admin, standard, or light. Send a PUT request with the new role, and you'll get the updated member profile back. ## Change a member's role via API `PUT /organizations/{org_id}/users/{user_id}/role` This endpoint changes a member's role in your Tallyfy organization. It's available to administrators only. ## Request Replace `{org_id}` with your Organization ID and `{user_id}` with the member's numeric ID. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` - `Content-Type: application/json` ### Body (JSON) Send a JSON object with the new role. The three valid roles are `admin`, `standard`, and `light`. - `role` (string, required): Must be one of `admin`, `standard`, or `light`. ```json { "role": "light" } ``` ## Code samples ## Response A `200 OK` response returns the member's full profile with the updated role. ```json { "data": { "id": 12345, "email": "specific.user@example.com", "first_name": "Specific", "last_name": "User", "role": "light", // ... other user properties ... } } ``` If the member isn't found, you'll get a `404`. An invalid role value returns `422`. Missing admin permissions returns `403`. --- - **[Update member](https://tallyfy.com/products/pro/integrations/open-api/code-samples/members/update-member/)**: Tallyfy's API lets admins update a member's profile (name, timezone, and optional fields like phone or job title) via a PUT request. It returns the full updated profile on success. ## Endpoint `PUT /organizations/{org_id}/users/{user_id}` Updates a member's profile within your Tallyfy organization. Requires **admin** permission. Members can also update their own profile via `PUT /organizations/{org_id}/me`. ## Request Replace `{org_id}` with your Organization ID and `{user_id}` with the member's numeric ID. ### Headers | Header | Value | |--------|-------| | Authorization | `Bearer {your_access_token}` | | Accept | `application/json` | | X-Tallyfy-Client | `APIClient` | | Content-Type | `application/json` | ### Body (JSON) Send a JSON object with the fields you want to update. Three fields are **required** in every request: **Required fields:** - `first_name` (string, max 32 chars) - can't be a URL or disallowed name - `last_name` (string, max 32 chars) - can't be a URL or disallowed name - `timezone` (string, e.g., `Europe/London`) **Optional fields:** - `phone` (string, max 20 chars) - `job_title` (string, nullable) - `job_description` (string, nullable) - `team` (string, nullable) - `country_id` (integer) - must match a valid country ID - `date_format` (string) - either `mm/dd/yyyy` or `dd/mm/yyyy` - `step_preferences` (boolean) ```json { "first_name": "Alicia", "last_name": "Smith-Jones", "job_title": "Senior Support Agent", "timezone": "America/New_York" } ``` :::note Email and password changes use separate endpoints (`/update-email` and `/update-password`) and may require the user's current password. Bot users can't be edited. If a member belongs to other organizations, only that member can update their own profile. ::: ### Code samples ## Response A successful request returns `200 OK` with the member's full profile after the update. ```json { "data": { "id": 12345, "email": "user@example.com", "first_name": "Alicia", "last_name": "Smith-Jones", "full_name": "Alicia Smith-Jones", "profile_pic": "https://...", "job_title": "Project Lead", "phone": "+1-555-123-4567", "team": "Operations", "timezone": "America/New_York", "UTC_offset": "-05:00", "country_id": 1, "date_format": "mm/dd/yyyy", "role": "standard", "status": "active", "created_at": "2024-01-15T10:30:00Z", "updated_at": "2026-02-25T14:20:00Z" } } ``` If the user ID isn't found, you don't have permission, or the request body fails validation, you'll get `404`, `403`, `400`, or `422` respectively. --- ### Processes - **[Activate process](https://tallyfy.com/products/pro/integrations/open-api/code-samples/processes/activate-process/)**: Tallyfy's API lets you restore an archived process run by sending a PUT request to the activate endpoint. This clears the `archived_at` field and brings the run back into default views while preserving its original status. ## Endpoint `PUT /organizations/{org_id}/runs/{run_id}/activate` This endpoint restores a previously archived process (called a "run" in the API). Once restored, the run's `archived_at` field becomes `null` and it reappears in default views. ## Request Replace `{org_id}` with your Organization ID and `{run_id}` with the run ID you want to restore. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Body This endpoint doesn't need a request body. ### Code samples ## Response A successful request returns `200 OK` with the restored run wrapped in a `data` object. The `archived_at` field will be `null`, and `status` retains whatever value it had before archiving (e.g., `active`, `complete`, or `problem`). ```json { "data": { "id": "PROCESS_RUN_ID_TO_ACTIVATE", "checklist_id": "template_id_here", "name": "Restored Project Run", "status": "active", "archived_at": null, "started_at": "2025-01-15T10:00:00.000Z", "last_updated": "2025-06-20T14:30:00.000Z" } } ``` If the run ID isn't found or you don't have access, you'll get a `404` or `403` error. --- - **[Archive process](https://tallyfy.com/products/pro/integrations/open-api/code-samples/processes/archive-process/)**: Tallyfy's API lets you soft-delete (archive) a running process via a DELETE request. The process disappears from default views while preserving all tasks and data, and you can restore it later using the activate endpoint. ## Endpoint `DELETE /organizations/{org_id}/runs/{run_id}` This endpoint archives (soft-deletes) a process. The process won't appear in default views, but all its data - tasks, comments, form values - stays intact. You can restore it later with `PUT .../runs/{run_id}/activate`. ## Request Replace `{org_id}` with your Organization ID and `{run_id}` with the process run ID. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Body No request body needed. ### Code samples ## Response A `200 OK` response with the archived process details wrapped in a `data` object. The `status` field changes to `archived` and `archived_at` gets a timestamp. ```json { "data": { "id": "PROCESS_RUN_ID_TO_ARCHIVE", "name": "Old Completed Project", "status": "archived", "archived_at": "2024-06-15T10:30:00.000Z", "checklist_id": "template_timeline_id", "progress": 75, "started_by": "user_id", "owner_id": "user_id", "created_at": "2024-01-10T08:00:00.000Z", "last_updated": "2024-06-15T10:30:00.000Z" } } ``` If the run ID isn't found or you don't have permission, you'll get a `404` or `403` error. Archiving also soft-deletes associated tasks, threads, and assets - all of which get restored when you reactivate the process. --- - **[Delete process](https://tallyfy.com/products/pro/integrations/open-api/code-samples/processes/delete-process/)**: Tallyfy's API lets admins permanently delete an archived process run and all its related data. Send a DELETE request to the `/runs/{run_id}/delete` endpoint, with code samples in six languages. ## Endpoint `DELETE /organizations/{org_id}/runs/{run_id}/delete` Permanently deletes an archived process (run) and all its related data -- tasks, comments, form field values, attachments, tags, and watchers. :::danger[Irreversible action] This can't be undone. All data tied to this run is permanently removed from the database. If you're unsure, archive the process first and leave it archived. ::: :::caution[Must be archived first] You can only permanently delete a process that's already been archived (soft-deleted). Calling this on an active process returns an error. Archive it first using `DELETE /organizations/{org_id}/runs/{run_id}`. ::: ## Request Replace `{org_id}` with your Organization ID and `{run_id}` with the run ID to delete. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Body No request body is needed. ### Code samples ## Response A successful permanent deletion returns `200 OK` with an empty response body. The process and all related data have been permanently removed. | Status | Meaning | |--------|---------| | `200` | Process permanently deleted | | `403` | You don't have admin role permissions | | `404` | Process not found (wrong ID or not archived) | | `422` | Process isn't archived yet -- archive it first | --- - **[Get activity feed for a process](https://tallyfy.com/products/pro/integrations/open-api/code-samples/processes/get-process-activity/)**: Tallyfy's activity feed API endpoint lets you pull a full audit trail of every event on a process, including task completions, comments, and status changes. Call GET on the activity-feeds resource with filters for entity type, verb, date range, and actor while supporting pagination and role-based access control. ## Retrieving process activity feed The activity feed gives you a full audit trail of everything that's happened on a process - task completions, comments, status changes, assignments, and system events. It's useful for compliance, auditing, and building custom dashboards. ## Endpoint `GET /organizations/{org}/activity-feeds` This endpoint returns activities across the entire organization. To scope it to a single process, pass `entity_type=run` and `entity_id={process_id}` as query parameters. ## Request ### Headers | Header | Required | Description | |--------|----------|-------------| | `Authorization` | Yes | `Bearer {access_token}` | | `Accept` | Yes | `application/json` | | `X-Tallyfy-Client` | Yes | `APIClient` | ### Query parameters | Parameter | Type | Required | Description | |-----------|------|----------|-------------| | `entity_type` | string | No* | Entity type to filter: `checklist`, `run`, `step`, `task`, `thread` | | `entity_id` | string | No* | ID of the specific entity | | `type` | string | No | Activity category: `Comment`, `Task`, `Step`, `Process`, `Blueprint`, `User`, `Organization`, `Tag`, `Group` | | `verb` | string | No | Action filter (see verb values below) | | `actor_type` | string | No | `user` or `guest` | | `actor_id` | integer | No | Specific user or guest ID | | `actor_email` | string | No | Actor's email -- resolves to `actor_id` and `actor_type` automatically | | `source` | string | No | `Member`, `Guest`, or `Webhook` | | `created_after` | string | No | Start date filter (YYYY-MM-DD format, inclusive) | | `created_before` | string | No | End date filter (YYYY-MM-DD format, inclusive) | | `search` | string | No | Search activity descriptions (2-100 characters) | | `field` | string | No | Filter by changed field name (e.g. `title`, `status`) | | `origin_type` | string | No | Filter auto-launched activities by origin: `checklist`, `run`, `step`, `task` | | `origin_id` | string | No | Specific origin entity ID (requires `origin_type`) | | `page` | integer | No | Page number (default: 1) | | `per_page` | integer | No | Results per page (default: 20) | | `sort` | string | No | Sort order, e.g. `-created_at` for newest first | *Use `entity_type=run` with `entity_id` to scope results to a single process. ### Verb values The full set of supported verbs: `created` · `updated` · `owners-updated` · `uploaded` · `completed` · `uncompleted` · `deleted` · `re-ordered` · `commented` · `issue-reported` · `issue-resolved` · `archived` · `unarchived` · `re-opened` · `emitted` · `enabled` · `disabled` · `comment-deleted` · `invited` · `invite-accepted` · `linked` · `unlinked` ## Code samples ## Response The response uses Fractal pagination wrapping. Activities sit in `data` and pagination metadata lives under `meta.pagination`. ```json { "data": [ { "id": 12345, "organization_id": "org_xyz", "verb": ["completed"], "source": ["Member"], "actor_type": ["App\\Models\\User"], "actor_id": [67890], "auditable_type": "App\\Models\\Task", "auditable_id": "task_456", "parentable_type": "App\\Models\\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": null, "actor": [ { "email": "john@example.com", "username": "johnsmith", "first_name": "John", "last_name": "Smith", "full_name": "John Smith", "profile_pic": null, "resize_profile_pic": null } ], "undoable": false, "audit": { "data": { } }, "parent": { "data": { } }, "origin": null } ], "meta": { "pagination": { "total": 145, "count": 20, "per_page": 20, "current_page": 1, "total_pages": 8, "links": { "next": "https://go.tallyfy.com/api/organizations/org_xyz/activity-feeds?page=2" } } } } ``` ### Activity object fields | Field | Description | |-------|-------------| | `id` | Activity feed ID | | `organization_id` | Organization the activity belongs to | | `verb` | Array of actions performed (e.g. `["completed"]`) | | `source` | Array indicating who triggered it: `Member`, `Guest`, or `Webhook` | | `actor_type` | Array of actor model types | | `actor_id` | Array of actor IDs | | `actor` | Array of actor detail objects with `email`, `first_name`, `last_name`, `full_name`, `profile_pic` | | `auditable_type` | Model class of the entity acted upon | | `auditable_id` | ID of the entity acted upon | | `parentable_type` | Model class of the parent entity | | `parentable_id` | ID of the parent entity | | `type` | Array of activity categories (e.g. `["Task"]`) | | `description` | Array of human-readable descriptions | | `field` | For updates, which field changed (array or null) | | `old_value` | For updates, the previous value (array or null) | | `created_at` | When the activity occurred | | `text` | Extra content such as comment text (array or null) | | `references` | Related references (array or null) | | `undoable` | Whether this activity can be undone | | `audit` | Fractal include -- current state of the audited object | | `parent` | Fractal include -- parent object details | | `origin` | Fractal include -- origin entity for auto-launched activities | | `audit_state` | Snapshot of the audited object's state (when available) | | `parent_state` | Snapshot of the parent object's state (when available) | ## Permissions The `activity_feed_access` middleware controls access. You can view the activity feed if you're: - An **organization admin** - A **support user** with appropriate access - The **creator** of the process (when filtering by `entity_type=run`) - A user with **PROCESS_READ** permission on that process - **Assigned** to at least one task in that process Without a specific `entity_type=run` filter, admins and support users see all org-level activities. Non-admin users see activities scoped to entities they have permission to access. ## Rate limits Rapid polling gets throttled with HTTP 429 responses. Use pagination and caching to stay within limits, and wait the number of seconds in the `Retry-After` header before retrying. - **[Get process](https://tallyfy.com/products/pro/integrations/open-api/code-samples/processes/get-process/)**: Retrieve full details of a specific process run by ID, with optional related data like tasks, form fields, and tags. The next_task option returns the earliest-deadline incomplete task for dashboards or notifications. ## Endpoint `GET /organizations/{org_id}/runs/{run_id}` Retrieves full details for a single process (run) by its unique ID. ## Request Replace `{org_id}` with your Organization ID and `{run_id}` with the run's ID. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Query parameters (optional) - `with` (string): Comma-separated list of related data to include. Options: `checklist`, `tasks`, `tags`, `assets`, `next_task`, `permissions`, `tasks_meta`, `ko_form_fields`, `form_fields`, `stages`, `folders`, `member_watchers`, `guest_watchers`. The controller also supports `tasks.threads` and `tasks.form_fields` for nested eager loading. - `form_fields_values` (boolean, e.g., `true`): Include values submitted to form fields across all tasks. #### Understanding `with=next_task` Including `next_task` returns the next task needing attention in the process. **What it returns:** - The first incomplete task, sorted by deadline (earliest deadline first) - **Incomplete** means not yet completed -- in-progress tasks are included - Auto-skipped tasks are excluded (they're filtered from the `tasks` relationship) - Returns as a collection wrapper: `"next_task": {"data": [...]}` - Returns an empty collection if all tasks are completed **Fields returned per task:** `id`, `increment_id`, `title`, `alias`, `owners` (with `users`, `guests`, `groups` arrays), and `deadline`. **When to use it:** - Showing which task a user should work on next - Automating notifications for upcoming deadlines - Building dashboards that display current process state ### Code samples ## Response Returns `200 OK` with the process run wrapped in a `data` object. ```json { "data": { "id": "run_id_abc", "increment_id": 5015, "checklist_id": "template_timeline_id", "checklist_title": "Client Onboarding V3", "name": "Onboarding - Globex Corp", "summary": "New client onboarding run.", "status": "active", "progress": { }, "whole_progress": { }, "started_by": 1002, "owner_id": 1002, "prerun": { }, "prerun_status": "complete", "starred": false, "created_at": "2025-05-20T11:00:00Z", "started_at": "2025-05-20T11:00:00Z", "last_updated": "2025-05-21T09:30:00Z", "archived_at": null, "completed_at": null, "type": "procedure", "is_public": false, "users": [], "groups": [], "checklist": { }, "tasks": { "data": [] }, "tags": { "data": [] } } } ``` Key fields: `archived_at` maps from the internal `deleted_at` column. `started_by` maps from the internal `user_id`. Included relationships like `tasks`, `tags`, and `checklist` only appear when you request them via `with`. The `prerun` object holds the kick-off form answers, keyed by each field's timeline ID. Each `prerun` value's shape depends on the field type. The per-type list lives on [Launch process](/products/pro/integrations/open-api/code-samples/processes/launch-process/). If the run isn't found or you don't have access, you'll get a `404` or `403` error. --- - **[Launch projects](https://tallyfy.com/products/pro/integrations/open-api/code-samples/processes/launch-process-without-template/)**: Tallyfy's API lets you create ad-hoc projects without a predefined template. Use the `separate_task_for_each_assignee` parameter on the one-off task endpoint to spin up an empty process container with individual tasks per assignee, then add more tasks by referencing the returned `run_id`. ## Launch a process as an "empty shell" project Normally in Tallyfy, you'd create a template and then launch it. But sometimes you need an ad-hoc project -- just a one-time set of tasks you want to track like a regular process. Tallyfy lets you launch an "empty process" with no predefined steps. You can then add one-off tasks to it and track everything together. Think of it as running simple one-off projects, not just repeatable processes from a template. ## How it works The one-off task creation endpoint (`POST /organizations/{org_id}/tasks`) accepts a `separate_task_for_each_assignee` parameter. When you set it to `true`, the system: 1. Creates an empty process using the internal MISC system template 2. Creates individual tasks -- one for each assignee 3. Links all tasks to that process for unified tracking ## API endpoint ``` POST https://go.tallyfy.com/api/organizations/{org_id}/tasks ``` ### Required headers | Header | Value | Required | |--------|-------|----------| | `Authorization` | `Bearer {access_token}` | Yes | | `X-Tallyfy-Client` | `APIClient` | Yes | | `Accept` | `application/json` | Yes | | `Content-Type` | `application/json` | Yes | ## 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 tasks (max 600 characters) | | `task_type` | string | Yes | One of: `task`, `approval`, `expiring`, `email`, `expiring_email` | | `owners` | object | Yes | Contains arrays of `users`, `guests`, and/or `groups` | | `deadline` | string | Yes | Deadline in `YYYY-MM-DD HH:MM:SS` format | | `separate_task_for_each_assignee` | boolean | No | Set to `true` to create an empty process container. When omitted or `false`, a standalone one-off task is created instead. | | `summary` | string | No | Description or instructions for the tasks | | `everyone_must_complete` | boolean | No | Whether all assignees must complete the task (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 | Block guests from commenting (default: `false`) | | `can_complete_only_assignees` | boolean | No | Only assignees can complete the task (default: `false`) | | `max_assignable` | integer | No | Maximum assignees allowed (default: `0` = 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 Each object in `form_fields` supports: | Field Property | Type | Required | Description | |----------------|------|----------|-------------| | `label` | string | Yes | Display label for the field | | `field_type` | string | Yes | One of: `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` types | | `guidance` | string | No | Help text for the field | | `position` | integer | No | Display order | **Things to know:** - 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 group member - The process uses a system "MISC" template that exists in every organization ## Code samples ## Adding more tasks to the same process If your process needs different tasks with unique titles, use a two-step approach: 1. Create the first task with `separate_task_for_each_assignee: true` to establish the process 2. Add more tasks to that process by passing the `run_id` from step 1 ## API response The API returns the first created task. When `separate_task_for_each_assignee` is `true`, the response includes the linked process (`run`) data: ```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", "started_at": "YYYY-MM-DD 09:00:00" } } } ``` To see all created tasks, query the process using the returned `run.id`. ## Good to know ## Error handling ```javascript try { const result = await createProcessWithoutTemplate(orgId, token, taskData); console.log(`Process created: ${result.data.run.id}`); } catch (error) { if (error.status === 401) { // Token expired -- refresh and retry await refreshToken(); return retry(); } else if (error.status === 422) { // Validation error (missing required fields, invalid task_type, etc.) console.error('Invalid task data:', error.response.errors); } else if (error.status === 429) { // Rate limited -- wait and retry await sleep(60000); return retry(); } else { console.error('Unexpected error:', error); throw error; } } ``` ## Tips 1. **Use clear titles** -- since these processes don't come from templates, descriptive titles help everyone understand what's going on 2. **Add context in `summary`** -- give assignees enough information to act on the task 3. **Set realistic deadlines** -- account for timezone differences and working hours 4. **Store the `run.id`** -- you'll need it to track progress and add more tasks later 5. **Handle failures gracefully** -- implement retry logic for transient errors - **[Launch process](https://tallyfy.com/products/pro/integrations/open-api/code-samples/processes/launch-process/)**: Tallyfy's Launch Process API endpoint (POST to /organizations/{org_id}/runs) lets you start a new process from a template. Provide a checklist_id with optional parameters like name, pre-filled kick-off form fields, and per-step assignee or deadline overrides. ## Launch process API endpoint This endpoint launches a new process (run) from a template (checklist/blueprint). :::note[API vs UI terminology] - 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) **Required field:** - `checklist_id` (string): The template ID to launch from. **Optional fields:** - `name` (string, max 550 chars): Name for this process instance. If it's omitted, auto-generates as `"{template title} - {date}"`. - `summary` (string): Description for this process instance. - `owner_id` (string): User ID of the process owner. - `user_id` (string): User ID of the process starter (must belong to the organization). - `starred` (boolean): Whether the process is starred. - `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` (object): Key-value pairs to pre-fill kick-off form fields, keyed by field timeline ID (see below). - `tasks` (object): Overrides for task properties like assignees and deadlines. Keys are step timeline IDs from the template. - `tags` (array of strings): Tag IDs to apply to this process. - `users` (array of strings): User IDs assigned to the process. - `groups` (array of strings): Group IDs assigned to the process. - `roles` (object): Role-based assignments, keyed by role ID. - `folders` (array of strings): Folder IDs where this process should appear. ### Populating kick-off fields with `prerun` The `prerun` object is keyed by **kick-off field timeline ID**. The value format 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) - **Radio button:** `{ "field_id_ghi": "Selected Option Value" }` - **Dropdown:** `{ "field_id_jkl": { "id": 2, "text": "Option Text", "value": null } }` - **Checklist (multi-select):** `{ "field_id_mno": [{ "id": 1, "text": "Option 1", "value": null, "selected": true }] }` - **Table:** `{ "field_id_stu": ["Widget", "3"] }` (one entry per column, in the order the columns are defined) - **Assignees:** `{ "field_id_vwx": { "users": [12345], "guests": ["guest@example.com"], "groups": ["group_id"] } }` - **File/Image:** `{ "field_id_pqr": [{ "id": "asset_id", "filename": "report.pdf", "version": 1, "url": "...", "uploaded_from": "ko_field", "subject": { "id": "template_id", "type": "Checklist" } }] }` (requires pre-uploading the file first) :::caution[Multi-select needs `selected: true` on every chosen option] An option without `"selected": true` passes validation and gets stored, so the request still returns `201 Created`. But anywhere that field is used as a `{{variable}}`, the value renders as empty text. If a multi-select value shows up blank in a task description or an email, this is almost always why. ::: #### Sending a table value A table value is a flat list with exactly one entry per column, in the order the columns are defined on the field. Send a different number of entries and the API rejects the whole request with `Number of columns does not match required columns`. For a table field with two columns, **Item** and **Qty**: ```json { "checklist_id": "template123", "prerun": { "a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4": ["Widget", "3"] } } ``` The first entry lands in the first column, the second in the second, and so on. To check the column order, call `GET /organizations/{org_id}/checklists/{checklist_id}` and read the `columns` array on that field inside the response's `prerun` array. That's the same response you use to look up the field's timeline ID. ### Overriding task properties with `tasks` The `tasks` object lets you set assignees and deadlines per step. Each key is a **step timeline ID** from the template. Assignees go inside an `owners` sub-object: ```json { "step_timeline_id": { "deadline": "2025-01-20T17:00:00Z", "owners": { "users": [12345], "guests": ["guest@example.com"], "groups": ["group_id"] } } } ``` :::note[Task assignment precedence] 1. Assignees in the `tasks` object override template step assignees. 2. If they're not specified, Tallyfy uses assignees from the template step. 3. If assignees don't exist anywhere, assignment depends on the step's `assign_run_starter` setting (defaults to `true`, meaning the launcher gets assigned). ::: ## Code samples ## Response A successful request returns a `201 Created` status code and a JSON object with the full details of the newly created process instance, wrapped in a `data` object. - **[List processes](https://tallyfy.com/products/pro/integrations/open-api/code-samples/processes/list-processes/)**: Use the GET runs endpoint to retrieve a paginated, filterable list of running processes in your organization. Supports optional parameters for status, ownership, tags, sorting, and including related data. ## Endpoint `GET /organizations/{org_id}/runs` This endpoint returns a paginated list of process instances (runs) in your organization. It's filterable by status, ownership, templates, and more. ## Request Replace `{org_id}` with your Organization ID. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Query parameters (optional) - `q` (string): Search processes by name. - `status` (string): Filter by status - `active`, `complete`, `problem`, `issue`, `improvement`, `archived`, `delayed`, or `starred`. A process gets the `issue` status while someone has an open process-level issue on it, and its tasks can't change until the issue is resolved. The `problem` filter also returns `issue` processes, so dashboards built on it keep showing everything that needs attention. Each process in the response carries a `has_open_issue` boolean. - `owners` (string): Comma-separated User IDs to filter by process owner or task assignee. - `checklist_id` (string): Filter by the template ID used to launch the process. Alias: `blueprint_id`. - `folder` (string): Filter by folder ID. - `tag` (string): Filter by a specific Tag ID. - `tag_ids` (string): Filter by comma-separated Tag IDs. - `untagged` (boolean): When set, returns only processes with no tags. - `starred` (boolean): Filter by starred status. - `type` (string): Filter by type - `procedure` or `form`. - `groups` (string): Comma-separated Group IDs involved in tasks within the process. - `with` (string): Comma-separated related data to include. Options: `checklist`, `tasks`, `tags`, `assets`, `next_task`, `permissions`, `tasks_meta`, `ko_form_fields`, `form_fields`, `stages`, `folders`. - `page` (integer): Page number to retrieve (default: 1). - `per_page` (integer): Results per page (default: 10). - `sort` (string): Field to sort by (e.g., `name`, `created_at`). Prefix with `-` for descending order (e.g., `-created_at`). Alias: `sort_by`. - `without_pagination` (boolean): When true, returns all results without pagination. ### Code samples ## Response You'll get a `200 OK` status and a JSON object with a `data` array. Each element represents a process run matching your filters. ```json { "data": [ { "id": "run_id_abc", "increment_id": 5012, "checklist_id": "template_id_123", "checklist_title": "Customer Onboarding", "name": "Onboarding - ACME Corp", "summary": "", "status": "active", "progress": { "complete": 5, "total": 10, "percent": 50 }, "whole_progress": { ... }, "started_by": 1001, "owner_id": 1001, "prerun": { ... }, "prerun_status": "complete", "starred": false, "created_at": "2025-01-15T10:00:00.000Z", "started_at": "2025-01-15T10:00:00.000Z", "last_updated": "2025-01-17T15:30:00.000Z", "archived_at": null, "completed_at": null, "due_date": "2025-02-15T10:00:00.000Z", "due_date_passed": false, "due_soon": false, "late_tasks": 0, "collaborators": [], "type": "procedure", "is_public": false, "users": [], "groups": [], "parent_id": null, "can_add_oot": true } ], "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 helps you page through results. You'll find the next page URL in `links.next`. The `prerun` object on each run holds that process's kick-off form answers, keyed by each field's timeline ID. Each `prerun` value's shape depends on the field type. The per-type list lives on [Launch process](/products/pro/integrations/open-api/code-samples/processes/launch-process/). --- - **[Update process](https://tallyfy.com/products/pro/integrations/open-api/code-samples/processes/update-process/)**: Tallyfy's API lets you partially update a running process by sending a PUT request with only the fields you want to change. Sending user or group arrays will fully replace all existing assignees of that type rather than appending to them. ## Endpoint `PUT /organizations/{org_id}/runs/{run_id}` Updates properties of an existing process (run). You only need to send the fields you want to change. ## Request Replace `{org_id}` with your Organization ID and `{run_id}` with the process run ID. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` - `Content-Type: application/json` ### Body (JSON) Send a JSON object with only the fields you want to modify. Here are the updatable fields: - `name` (string): Process name (max 550 characters). - `summary` (string): Process description text. - `owner_id` (string): User ID of the new process owner. Must belong to the organization. - `starred` (boolean): Whether the process is starred/favorited. - `is_public` (boolean): Whether the process is publicly accessible. - `publicly_hidden_fields` (array): Field IDs to hide from public view. - `users` (array of strings): User IDs assigned to the process. **Replaces** all current user assignees. - `groups` (array of strings): Group IDs assigned to the process. **Replaces** all current group assignees. - `prerun` (object): Update kick-off form field values. Keys are field timeline IDs, values depend on field type. See [Launch process](/products/pro/integrations/open-api/code-samples/processes/launch-process/). :::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 assignee arrays] Sending `users` or `groups` arrays **replaces** all existing assignees of that type. Fetch the current process first if you need to add or remove individual assignees without losing the rest. ::: **Example body:** ```json { "name": "Onboarding - Globex Corp (Updated)", "summary": "Updated summary notes for this run.", "starred": true, "users": ["user_id_1", "user_id_2"] } ``` ## Code samples ## Response Returns `200 OK` with the full updated process wrapped in a `data` object. ```json { "data": { "id": "PROCESS_RUN_ID_TO_UPDATE", "checklist_id": "template_timeline_id", "checklist_title": "Onboarding Template", "name": "Onboarding - Globex Corp (Updated)", "summary": "Updated summary notes for this run.", "status": "active", "progress": 25, "owner_id": "user_id", "starred": true, "is_public": false, "users": [], "groups": [], "created_at": "2025-01-15T10:00:00Z", "last_updated": "2025-01-20T14:30:00Z" } } ``` If the run ID isn't found, you don't have permission, or the request body is invalid, you'll get a `404`, `403`, or `422` error response. --- ### Templates - **[Create a template](https://tallyfy.com/products/pro/integrations/open-api/code-samples/templates/create-template/)**: Tallyfy's API lets you create a new process template by sending a POST request to the checklists endpoint with a required title and type (procedure/form/document) along with optional settings like owner assignment, kick-off form fields, webhook URLs, and access controls. It returns the full template object with a 201 status code. Send a `POST` request to create a new template (it's called a "checklist" in the API) inside an organization. The response returns the newly created template with a **201 Created** status. ## Endpoint ```http POST https://go.tallyfy.com/api/organizations/{org}/checklists ``` ### Path parameters | Parameter | Type | Description | | :-------- | :------- | :------------------------------------- | | `org` | string | **Required.** The organization ID. | ### Body parameters Pass a JSON object with the template properties you want to set. | Parameter | Type | Description | | :----------------------------- | :------ | :--------------------------------------------------------------------------------------------------------- | | `title` | string | **Required.** Template title (max 250 characters). | | `type` | string | **Required.** One of `procedure`, `form`, or `document`. | | `summary` | string | Short description (max 2000 characters). | | `owner_id` | integer | Member ID of the template owner. Must belong to the organization. | | `user_id` | integer | Member ID of the template starter. Must belong to the organization. | | `webhook` | string | URL for webhook notifications on template events. Must be a valid URL. | | `explanation_video` | string | URL of a video explaining the template. Must be a valid URL. | | `starred` | boolean | Whether to star the template. | | `guidance` | string | Instructions or guidance for using the template. | | `icon` | string | Icon name to associate with the template. | | `is_public` | boolean | Make the template publicly visible in the library. | | `is_featured` | boolean | Feature the template in the public library. | | `public_cover` | string | Cover image URL for the public library listing. | | `folder_id` | string | ID of an existing folder to place the template in. | | `default_process_name_format` | string | Format string for auto-naming processes launched from this template. | | `is_public_kickoff` | boolean | Make the kick-off form publicly accessible. | | `auto_naming` | boolean | Turn on automatic process naming using `default_process_name_format`. | | `dual_version_enabled` | boolean | Enable dual-version (draft/published) mode. | | `users` | array | Array of member IDs who get default access to this template. | | `groups` | array | Array of group IDs that get default access to this template. | | `prerun` | array | Array of objects defining kick-off form fields. Each needs `label`, `field_type`, and `required` at minimum.| | `folderize_process` | boolean | Auto-create a folder for processes launched from this template. | | `tag_process` | boolean | Auto-tag processes launched from this template. | | `allow_launcher_change_name` | boolean | Let the launcher override the default process name. Only applies when `auto_naming` is off. | | `can_add_oot` | boolean | Allow adding one-off tasks to processes from this template. | ## Code samples ## Example response (201 Created) A successful call returns the full template object wrapped in `data`: ```json { "data": { "id": "b3d9c1a8e7f6...", "increment_id": 42, "title": "New Client Onboarding Template", "summary": "Standard procedure for onboarding new clients.", "starred": false, "webhook": null, "guidance": null, "alias": "new-client-onboarding-template-b3d9c1", "folder_id": null, "prerun": [], "created_by": 123, "owner_id": 12345, "kickoff_title": null, "kickoff_description": null, "started_processes": 0, "created_at": "2025-10-27T10:00:00.000Z", "last_updated": "2025-10-27T10:00:00.000Z", "archived_at": null, "is_public": false, "automated_actions": [], "topic_tags": [], "industry_tags": [], "public_cover": null, "icon": null, "type": "procedure", "steps_count": 0, "is_public_kickoff": false, "default_process_name_format": null, "dual_version_enabled": false, "is_published_state": false, "is_featured": false, "auto_naming": false, "last_updated_by": 123, "status": null, "explanation_video": null, "users": [], "groups": [], "is_pinned": false, "folderize_process": false, "tag_process": false, "allow_launcher_change_name": false, "ko_form_blueprint_id": null, "default_folder": null, "folder_changeable_by_launcher": false, "can_add_oot": false, "kickoff_sharing_user_id": null } } ``` - **[Archive or delete template](https://tallyfy.com/products/pro/integrations/open-api/code-samples/templates/delete-archive-template/)**: Tallyfy''s API lets you remove templates in two steps. First archive (soft delete) with a DELETE request, then permanently delete with a second DELETE request using the /delete path segment. There are two ways to remove a template via the API: 1. **Archive (soft delete):** Hides the template but keeps its data. Processes already launched from it keep running. Archived templates can be restored. 2. **Delete (permanent):** Permanently removes the template and its associated data. This can't be undone. The template must be archived first before it can be permanently deleted. ## 1. Archive a template ### Endpoint `DELETE /organizations/{org_id}/checklists/{checklist_id}` This archives the specified template (soft delete). ### Request Replace `{org_id}` with your Organization ID and `{checklist_id}` with the template ID. #### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` #### Body No request body is needed. ### Code samples ### Response A successful archive returns `200 OK` with a confirmation message and a list of deleted references (e.g., from automations or recurring jobs that referenced this template). ```json { "message": "The Template was deleted, and references were also deleted from:", "deleted_references": {} } ``` ## 2. Permanently delete a template :::danger[Irreversible action] Permanently deleting a template can't be undone. All associated template data will be lost. The template must already be archived before you can permanently delete it. This endpoint requires admin permissions. ::: ### 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 delete ### Response A successful permanent deletion returns `200 OK`. The response body contains a confirmation message and a list of deleted references. If the template isn't archived yet, you'll get an error - you must archive it first. ```json { "message": "The Template was deleted, and references were also deleted from:", "deleted_references": {} } ``` - **[Get template](https://tallyfy.com/products/pro/integrations/open-api/code-samples/templates/get-template/)**: Tallyfy's API lets you fetch full details of any process template by its unique ID using a GET request. You can also include related data like steps and tags through query parameters. ## Endpoint `GET /organizations/{org_id}/checklists/{checklist_id}` This endpoint retrieves full details for a single process template identified by its unique ID. ## Request Replace `{org_id}` with your Organization ID and `{checklist_id}` with the template ID you want. ### 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. Accepted values are `steps`, `tags`, and `folder`. Including `steps` automatically loads nested relations like form fields, comments, assigned users, guests, and groups. Example: `with=steps,tags` - `entire_folder_tree` (string, `"0"` or `"1"`): Include the template's full folder hierarchy in the response. ### Code samples ## Response A successful request returns a `200 OK` status code and a JSON object with a `data` field containing the template details. ```json { "data": { "id": "YOUR_TEMPLATE_ID", "title": "Customer Onboarding Process", "summary": "Standard process for onboarding new customers.", "starred": false, "webhook": null, "guidance": "Detailed guidance notes here.", "alias": "customer-onboarding-v2", "folder_id": null, "prerun": [ { "id": "a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6", "checklist_id": "YOUR_TEMPLATE_ID", "alias": "customer_name", "label": "Customer name", "field_type": "text" } ], "created_by": 1001, "owner_id": 1001, "kickoff_title": null, "kickoff_description": null, "created_at": "2025-01-10T10:00:00.000Z", "last_updated": "2025-05-15T14:30:00.000Z", "archived_at": null, "is_public": false, "automated_actions": [], "icon": "fa-users", "type": "procedure", "is_public_kickoff": false, "default_process_name_format": null, "explanation_video": null, "status": "active", "steps": [ { "id": "step_1_id", "checklist_id": "YOUR_TEMPLATE_ID", "alias": "welcome_call", "title": "Schedule Welcome Call" } ], "tags": [ { "id": "tag_abc", "title": "Onboarding", "color": "#3498db" } ] } } ``` The `steps` and `tags` arrays only appear when you request them via the `with` parameter. Kick-off form fields (`prerun`) and automation rules (`automated_actions`) are always included. :::tip[This is where you get IDs for pre-filling a kick-off form] The `id` on each entry of the `prerun` array is that field's timeline ID, a 32-character hex string. It's the key you use in the `prerun` object when you [launch a process](/products/pro/integrations/open-api/code-samples/processes/launch-process/) with values already filled in. Use the `id`, not the `alias` sitting beside it. An alias key matches no field, and Tallyfy drops keys it can't match without an error, so the process launches fine with that field left empty. ::: If the template isn't found or you don't have permission, you'll get a `404 Not Found` error. --- - **[List templates](https://tallyfy.com/products/pro/integrations/open-api/code-samples/templates/list-templates/)**: Retrieve a paginated list of process templates from your Tallyfy organization using the API. Filter by title, status, tags, or owner, with code samples in JavaScript, Python, Java, Go, C++, and C#. ## List all templates This endpoint returns a paginated list of templates (they're called "checklists" in the API) for a given organization. :::note[API vs UI terminology] The Tallyfy UI calls these **Templates**, but the API uses **Checklists** in its endpoints and responses. ::: ## Endpoint `GET /organizations/{org_id}/checklists` ## Request Replace `{org_id}` with your Organization ID. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Query parameters (optional) | Parameter | Type | Description | |-----------|------|-------------| | `q` | string | Search templates by title (case-insensitive partial match) | | `page` | integer | Page number for pagination | | `per_page` | integer | Results per page (default: 10) | | `sort_by` | string | Field to sort by (prefix with `-` for descending) | | `with` | string | Comma-separated includes: `steps`, `tags`, `folder`, `permissions`, `stages`, `linked_tasks`, `assets`, `member_watchers`, `guest_watchers` | | `status` | string | Filter by template status | | `type` | string | Filter by template type | | `starred` | string | Filter starred templates | | `folder` | string | Filter by folder | | `tag` | string | Filter by tag | | `owner_id` | string | Filter by owner | | `archived` | string | Set to `only` for archived templates, or any truthy value to include them | ### Code samples ## Response You'll get a `200 OK` status and a JSON object with a `data` array. Each item in the array represents a template with fields like `id`, `title`, `summary`, `starred`, `type`, `status`, `owner_id`, `created_by`, `created_at`, `last_updated`, and more. ```json { "data": [ { "id": "c15bf2be31c3a7fbded5d13fce7aaab9", "title": "Customer Onboarding Process", "summary": "Standard process for onboarding new customers.", "starred": false, "type": "procedure", "status": "active", "owner_id": "user_abc123", "created_by": "user_abc123", "steps_count": 8, "is_pinned": false, "created_at": "2025-01-10T10:00:00.000Z", "last_updated": "2025-05-15T14:30:00.000Z" } ], "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" } } } } ``` The `meta.pagination` object tells you the total count, current page, items per page, and provides `links` for navigating between pages. They're sorted by pinned status first, then by your `sort_by` parameter (defaults to `updated`). --- - **[Update template](https://tallyfy.com/products/pro/integrations/open-api/code-samples/templates/update-template/)**: Use the Tallyfy API to update an existing template's properties through a PUT request. The title field is required, and array fields like users and groups fully replace existing lists. ## Endpoint `PUT /organizations/{org_id}/checklists/{checklist_id}` Updates the properties of an existing template (blueprint) by its ID. ## Request Replace `{org_id}` with your Organization ID and `{checklist_id}` with the template ID. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` - `Content-Type: application/json` ### Body (JSON) Send a JSON object with the fields you want to change. The `title` field is **required** on every update request (max 250 characters). All other fields are optional. **Required field:** - `title` (string, required) - Template title, max 250 characters **Common optional fields:** - `owner_id` (string) - Must be a valid user in your organization - `webhook` (string) - Must be a valid URL - `guidance` (string) - Guidance text for the template - `icon` (string) - Icon identifier - `folder_id` (string) - Folder ID to organize this template - `is_public` (boolean) - Make the template publicly accessible - `is_public_kickoff` (boolean) - Enable public kick-off form - `explanation_video` (string) - Must be a valid URL - `default_process_name_format` (string, max 550) - Auto-naming format for launched processes - `auto_naming` (boolean) - Enable automatic process naming - `users` (array of strings) - Replaces the entire existing user list - `groups` (array of strings) - Replaces the entire existing group list **Example body:** ```json { "title": "Updated Template Name", "guidance": "New guidance notes for this template." } ``` :::caution[Updating arrays (users/groups)] When you update `users` or `groups`, the provided array *replaces* the entire existing list. It won't append new entries, so make sure you include the complete intended list. ::: ### Code samples ## Response A successful request returns a `200 OK` status code and a JSON object with the full template details after the update. ```json { "data": { "id": "TEMPLATE_ID_TO_UPDATE", "title": "Updated via JS Fetch", "guidance": "New guidance added via API.", "owner_id": "user_id_here", "webhook": null, "is_public": false, "type": "procedure", "users": [], "groups": [], "last_updated": "2026-01-15T12:30:00.000Z" } } ``` If the template isn't found, you'll get a `404`. Permission issues return `403`. Validation errors - like a missing `title` - return `422`. --- ### Tasks - **[Archive task](https://tallyfy.com/products/pro/integrations/open-api/code-samples/tasks/archive-task/)**: Tallyfy's API lets you soft-delete (archive) a standalone one-off task by sending a DELETE request to `/organizations/{org_id}/tasks/{task_id}`. The task won't appear in default views, but all data is preserved and can be restored later. ## Endpoint `DELETE /organizations/{org_id}/tasks/{task_id}` This endpoint soft-deletes (archives) a standalone one-off task. The task won't appear in default views, but its data is preserved. You can restore it later with `PUT /organizations/{org_id}/tasks/{task_id}/restore`. :::note This only works for **one-off tasks** (tasks without a `run_id`). To archive tasks within a process, 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 task ID to archive. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Body You don't need a request body. ## Code samples ## Response A successful request returns a `204 No Content` status with an empty response body. The task is soft-deleted -- its `deleted_at` timestamp gets set, hiding it from default views while keeping all data intact. - **[Complete task](https://tallyfy.com/products/pro/integrations/open-api/code-samples/tasks/complete-task/)**: Mark process tasks or standalone tasks as complete by POSTing the task ID to the right endpoint. Optionally handle approval decisions or override the completing user, with all required form fields filled beforehand. ## Endpoint This endpoint marks a task as complete. The URL differs depending on whether it's a process task or a standalone task: - **Process task:** `POST /organizations/{org_id}/runs/{run_id}/completed-tasks` - **Standalone task:** `POST /organizations/{org_id}/completed-tasks` Replace `{org_id}` and `{run_id}` with your actual IDs. ## Request ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` - `Content-Type: application/json` ### Body (JSON) **Fields:** - `task_id` (string, **required**) - The ID of the task to complete. - `is_approved` (boolean, **required for approval tasks**) - Set `true` to approve, `false` to reject. Ignored for non-approval tasks. - `override_user` (integer, optional) - User ID to record as the completer instead of the authenticated user. > **Note:** You can't send form field values in the completion request. Update form fields through the [Update Task](/products/pro/integrations/open-api/code-samples/tasks/update-task/) endpoint before completing. The API validates that all required form fields are filled before allowing completion. **Example body (simple completion):** ```json { "task_id": "TASK_ID_TO_COMPLETE" } ``` **Example body (approval task - approve):** ```json { "task_id": "APPROVAL_TASK_ID", "is_approved": true } ``` ## Code samples These examples use the process task endpoint. For standalone tasks, drop the `/runs/{run_id}` segment from the URL. ## Response A successful request returns `200 OK` with the completed task details. ```json { "data": { "id": "TASK_ID_TO_COMPLETE", "title": "Review Proposal", "status": "completed", "completed_at": "2025-05-20T17:00:00.000Z", "completer_id": 1001, "tasks_changed_by_rules": {} } } ``` For process tasks, the response includes `tasks_changed_by_rules` showing any tasks affected by automation rules triggered by this completion. Standalone task responses don't include this field. The API returns an error if the task is already completed, the user lacks permission, required form fields aren't filled, or the task has unresolved issues. --- - **[Create one-off task](https://tallyfy.com/products/pro/integrations/open-api/code-samples/tasks/create-task/)**: Tallyfy's API lets you create standalone one-off tasks outside any process. Send a POST request with required fields like title, task type, assignees, and deadline, plus optional settings like form fields, webhooks, and confidentiality flags. ## Endpoint `POST /organizations/{org_id}/tasks` Creates a standalone one-off task that isn't part of any process run. ## 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) #### Required fields - `title` (string, max 600 chars): The task title. - `task_type` (string): One of `task`, `approval`, `expiring`, `email`, or `expiring_email`. - `owners` (object): Assignees - structure: `{ "users": [], "guests": ["email@example.com"], "groups": [] }`. - `deadline` (string): Due date/time in ISO 8601 format. #### Optional fields - `description` (string): Instructions or details for the task. - `started_at` (string): Start date/time in ISO 8601 format. - `separate_task_for_each_assignee` (boolean): If `true`, creates one task per assignee. - `max_assignable` (integer): Maximum number of assignees allowed. - `prevent_guest_comment` (boolean): Block guests from commenting. - `everyone_must_complete` (boolean): Whether all assignees must complete the task. - `can_complete_only_assignees` (boolean): Only assigned people can complete it. - `tags` (array of strings): 32-character tag IDs to apply. - `form_fields` (array): Form fields to capture data on completion. - `webhook` (string): URL to call when the task's completed. - `top_secret` (boolean): Mark the task as confidential. - `run_id` (string): Link this task to an existing process run. **Example body:** ```json { "title": "Prepare Q3 Report", "task_type": "task", "description": "Gather data and prepare the quarterly report slides.", "owners": { "users": [1001, 1002], "groups": [], "guests": [] }, "deadline": "2025-07-15T17:00:00Z", "tags": ["a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4"] } ``` ## Code samples ## Response A successful request returns a `201 Created` status and a JSON object with the new task's details. ```json { "data": { "id": "new_one_off_task_id_789", "increment_id": 1250, "title": "Python One-Off Task: Plan Meeting", "run_id": null, "step_id": null, "status": "not-started", "task_type": "task", "owners": { "users": [ { "id": 1001, "full_name": "Bob", "profile_pic": "..." } ], "guests": [], "groups": [] }, "deadline": "2025-06-30T17:00:00.000Z", "started_at": null, "created_at": "2025-05-20T18:00:00.000Z", "last_updated": "2025-05-20T18:00:00.000Z" } } ``` Save the returned `id` -- you'll need it to get, update, complete, or delete this task later. --- - **[Delete task](https://tallyfy.com/products/pro/integrations/open-api/code-samples/tasks/delete-task/)**: Tallyfy's API lets you permanently delete a standalone one-off task along with its form fields and captured values. The DELETE request returns a 204 No Content response on success and can't be undone. ## Endpoint `DELETE /organizations/{org_id}/tasks/{task_id}/delete` This permanently deletes a standalone (one-off) task along with its form fields and captured values. It can't be undone. :::danger[Irreversible action] Permanent deletion wipes the task, its form fields, and all captured form values. You can't recover any of it. Archive the task instead if you might need it later. ::: :::note This only works on **one-off tasks** -- not tasks created by a process run. To remove process tasks, delete the entire run with `DELETE /organizations/{org_id}/runs/{run_id}/delete`. ::: ## Request Replace `{org_id}` with your Organization ID and `{task_id}` with the task ID you want to permanently delete. ### Headers | Header | Value | |--------|-------| | `Authorization` | `Bearer {your_access_token}` | | `Accept` | `application/json` | | `X-Tallyfy-Client` | `APIClient` | ### Body No request body is needed. ### Code samples ## Response A successful deletion returns `204 No Content` with no response body. If the task doesn't exist or you lack permission, you'll get an error status (`404`, `403`) with details in the response body. --- - **[Get task](https://tallyfy.com/products/pro/integrations/open-api/code-samples/tasks/get-task/)**: Tallyfy's API lets you fetch any single task by its ID using a GET request and optionally include related data like form fields and process run details through query parameters. ## Endpoint `GET /organizations/{org_id}/tasks/{task_id}` Retrieves a single task by its ID. This works for both standalone (one-off) tasks and process tasks. For process tasks, you can also use `GET /organizations/{org_id}/runs/{run_id}/tasks/{task_id}`. ## Request Replace `{org_id}` with your Organization ID and `{task_id}` with the task's unique ID. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Query parameters (optional) - `with` (string): Comma-separated list of related data to include. Options: `run`, `step`, `form_fields`, `tags`, `threads`, `issues`, `assets`, `folders`, `roles`, `activities`, `ko-form-fields`, `summary`, `member_watchers`, `guest_watchers`, `threads_count`. Example: `with=run,step,form_fields`. ### Code samples ## Response Returns a `200 OK` with a JSON object containing a `data` field that holds the task's full details. ```json { "data": { "id": "task_id_abc", "increment_id": 1205, "title": "Review Proposal", "run_id": "run_id_xyz", "checklist_id": "checklist_id_123", "step_id": "step_id_456", "alias": "review-proposal", "status": "active", "status_label": "Active", "task_type": "task", "is_oneoff_task": false, "is_completable": true, "is_approved": false, "owners": { "users": [1234], "guests": [], "groups": [] }, "position": 1, "started_at": "2025-01-10T09:00:00Z", "deadline": "2025-01-15T17:00:00Z", "created_at": "2025-01-10T09:00:00Z", "last_updated": "2025-01-12T14:30:00Z", "completed_at": null, "archived_at": null, "starter_id": 1234, "completer_id": null, "everyone_must_complete": false, "can_complete_only_assignees": true, "max_assignable": 1, "webhook": null, "top_secret": false, "form_fields": { "data": [ { "id": "capture_id_abc", "label": "Approval Status", "field_type": "dropdown", "value": { "id": 1, "text": "Approved" }, "required": true } ] }, "run": { "data": { "...": "process run details" } }, "step": { "data": { "...": "template step details" } } } } ``` The `form_fields`, `run`, and `step` objects only appear when you request them via the `with` parameter. If the task isn't found, you'll get a `404`. If you don't have permission, expect a `403`. --- - **[List organization tasks](https://tallyfy.com/products/pro/integrations/open-api/code-samples/tasks/list-org-tasks/)**: Retrieve and filter all tasks across your organization, including process-based and one-off tasks. You'll find query parameters for status, deadline, assignment, sorting, and pagination with code examples in six languages. ## Endpoint `GET /organizations/{org_id}/tasks` Retrieves all [tasks](/products/pro/tracking-and-tasks/tasks/) across every [process](/products/pro/tracking-and-tasks/processes/) and one-off task in the specified organization. You can filter, sort and paginate the results. ## 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) - `q` (string): Search by process name or step name. - `status` (string): Filter by task status - `active`, `complete`, `incomplete`, `inprogress`, `overdue`, `due_soon`, `hasproblem`. - `owners` (string): Comma-separated [User IDs](/products/pro/documenting/members/) to filter tasks assigned to *any* of these users. - `guests` (string): Comma-separated [Guest emails](/products/pro/documenting/guests/). - `roles` (string): Comma-separated [Role IDs](/products/pro/documenting/members/). - `groups` (string): Comma-separated [Group IDs](/products/pro/documenting/groups/). - `tag` (string): Filter by [Tag](/products/pro/documenting/templates/how-to-manage-templates-and-processes-with-tags/) name. - `folder` (string): Filter by [folder ID](/products/pro/tracking-and-tasks/tasks-view/how-can-i-add-tasks-to-folders-in-tallyfy/). - `created` (string): Filter by creation date (`YYYY-MM-DD` or `YYYY-MM-DD:YYYY-MM-DD` range). - `deadline_start_range` / `deadline_end_range` (string): Filter by deadline date range (`YYYY-MM-DD`). - `deadline_on` (string): Filter tasks with deadline on an exact date (`YYYY-MM-DD`). Takes precedence over other deadline filters. - `deadline_before` / `deadline_after` (string): Filter tasks with deadline before or after a given date (`YYYY-MM-DD`). - `is_oneoff` (string): Set to `true` for one-off tasks only, `false` for process tasks only. - `unassigned` (boolean): Set to `true` to return only tasks with no assignees. - `archived` (string): Set to `true` to include archived (soft-deleted) tasks, or `only` to return just archived tasks. - `with` (string): Include related data. Options: `run`, `run.checklist`, `step`, `threads`, `assets`, `form_fields`, `tags`, `summary`, `selected_text_comment`. Separate multiple values with commas. - `page`, `per_page` (integer): Pagination controls. Default `per_page` is 10. - `sort` (string): Sort results - `deadline`, `newest`, `problems`, `completed_newest`, or prefix with `-` for descending (e.g. `-deadline`). - `without_pagination` (string): Set to `true` to return all results at once. Use carefully on large datasets. ## Code samples ## Response A `200 OK` response returns a JSON object with a `data` array of task objects. There's also a `meta` object for pagination. ```json { "data": [ { "id": "task_id_abc", "increment_id": 1205, "title": "Review Proposal", "run_id": "run_id_xyz", "checklist_id": "checklist_id_456", "step_id": "step_id_123", "alias": "step_alias", "status": "active", "status_label": "Active", "task_type": "task", "position": 2, "is_oneoff_task": false, "owners": { "users": [ { "id": 1001, "full_name": "Alice" } ], "guests": [], "groups": [] }, "deadline": "2026-03-15T17:00:00Z", "started_at": "2026-03-01T09:00:00Z", "created_at": "2026-03-01T09:00:00Z", "last_updated": "2026-03-01T09:30:00Z", "completed_at": null, "is_completable": true, "everyone_must_complete": false } ], "meta": { "pagination": { "total": 50, "count": 10, "per_page": 10, "current_page": 1, "total_pages": 5 } } } ``` Fields like `run_id`, `checklist_id`, and `step_id` are `null` for one-off tasks. The `summary` field won't appear unless you pass `with=summary`. --- - **[List process tasks](https://tallyfy.com/products/pro/integrations/open-api/code-samples/tasks/list-process-tasks/)**: Retrieve all tasks for a specific process run through Tallyfy's API. Filter by status, deadline, or owner, sort and paginate results, and include related data like form fields or step details. ## Endpoint `GET /organizations/{org_id}/runs/{run_id}/tasks` Returns all tasks for a specific process run. ## Request Replace `{org_id}` with your Organization ID and `{run_id}` with the run ID whose tasks you want. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Query parameters (optional) - `status` (string): Filter by task status - `complete`, `active`, `active_visible`, `incomplete`, `inprogress`, `not-started`, `hasproblem`, `overdue`, `due_soon`. Tasks hidden by rules appear with `auto-skipped` status in responses but can't be used as a filter value. - `owners` (string): Comma-separated User IDs. - `guests` (string): Comma-separated Guest emails. - `groups` (string): Comma-separated Group IDs. - `unassigned` (boolean): Filter for unassigned tasks. - `deadline_start_range` / `deadline_end_range` (string): Filter by deadline range. - `deadline_on` (string): Filter tasks with deadline on an exact date (YYYY-MM-DD). Takes precedence over range filters. - `deadline_before` / `deadline_after` (string): Filter tasks with deadline before or after a date (YYYY-MM-DD), exclusive. - `with` (string): Include related data - `step`, `threads`, `comments`, `assets`, `form_fields`, `activities`, `run`, `run.checklist`, `summary`. Comma-separate multiple values. - `page`, `per_page` (integer): Pagination controls. Default `per_page` is 10. - `sort` (string): Sort by `position`, `deadline` (or `-position`, `-deadline` for descending). - `without_pagination` (boolean): Set to `true` if you don't want paginated results. ### Code samples ## Response You'll get a JSON object with a `data` array of tasks and a `meta` object for pagination. ```json { "data": [ { "id": "task_id_1", "increment_id": 1210, "title": "Welcome Call", "run_id": "PROCESS_RUN_ID", "checklist_id": "template_id", "step_id": "step_id_welcome", "alias": "welcome_call", "status": "active", "position": 1, "owners": { "users": [...], "guests": [...], "groups": [...] }, "deadline": "2025-05-28T17:00:00Z", "created_at": "2025-05-20T10:00:00Z", "last_updated": "2025-05-25T14:30:00Z", "completed_at": null, "task_type": "task", "is_oneoff_task": false, // Included when requesting with=step: "step": { "id": "step_id_welcome", "title": "Schedule Welcome Call" } }, { "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 } ], "meta": { "pagination": { ... } } } ``` --- - **[Reopen task](https://tallyfy.com/products/pro/integrations/open-api/code-samples/tasks/reopen-task/)**: Reopen a completed task by sending a DELETE request to the completed-tasks endpoint. This removes the completion record, resets the task status to in-progress, and clears fields like completed_at and completer_id. ## Endpoint Send a `DELETE` request to the `completed-tasks` resource to reopen a finished task. This sets the task's status back to `in-progress` and nulls out `completed_at`, `completer_id`, `completer_guest_id`, and `is_approved`. - **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 your actual IDs. :::note You're sending `DELETE` to the `completed-tasks` endpoint - think of it as deleting the completion record, not the task itself. ::: ## Request ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Body You don't need a request body. ### Code samples ## Response A `200 OK` response returns the reopened task with its status set to `in-progress`. ```json { "data": { "id": "TASK_ID_TO_REOPEN", "title": "Review Proposal", "status": "in-progress", "completed_at": null, "completer_id": null, "completer_guest_id": null, "is_approved": null } } ``` For process tasks, the response also includes a `tasks_changed_by_rules` field showing any sibling tasks affected by automation rules triggered by the reopen. If the task isn't currently completed or the ID is invalid, expect an error status code. --- - **[Update task](https://tallyfy.com/products/pro/integrations/open-api/code-samples/tasks/update-task/)**: Tallyfy's API lets you update any task (process or one-off) via a PUT request where you can change the title, deadline, assignees, form field values, and other properties. Assignee updates replace the entire list rather than merging, and different field types like dropdowns and checkboxes require specific JSON formatting. ## Endpoint Use a different URL depending on the task type: - **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 actual IDs. ## Request ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` - `Content-Type: application/json` ### Body (JSON) Send a JSON object with only the fields you want to change. Updatable fields include: - `title` (string): New task title. Max 600 characters. - `summary` (string): New task description. - `deadline` (string): New deadline in ISO 8601 format (e.g., `YYYY-MM-DDTHH:mm:ssZ`). Deadlines are automatically adjusted to the organization's working days. - `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). - `webhook` (string): Update the task-specific webhook URL. - `prevent_guest_comment` (boolean): Enable/disable guest comments. - `position` (integer): Change the task's position order. - `max_assignable` (integer): Set the maximum number of assignees. :::caution[One-off tasks require more fields] For one-off tasks, `title`, `deadline`, and `owners` are **required** in every update request. For process tasks, all fields are optional - include only what you're changing. ::: ### Updating form fields with `taskdata` Include a `taskdata` object in the request body. Keys are **form field timeline IDs**, and values depend on the field type. `taskdata` and the `prerun` object used when [launching a process](/products/pro/integrations/open-api/code-samples/processes/launch-process/) run through the same validator, so the value shapes below are identical on both surfaces. | Field type | Value to send | |------------|---------------| | Short text | A plain string, max 200 characters | | Long text (textarea) | A plain string, max 30,000 characters | | Email | A plain string | | Date | An ISO 8601 string: `"2025-12-31T23:59:59Z"` | | Radio button | The option's text as a bare string: `"Full-time"` | | Dropdown | One object with both keys: `{ "id": 3, "text": "Office 365", "value": null }` | | Checklist (multi-select) | A list of those objects, each with `"selected"`: `[{ "id": 1, "text": "Slack", "selected": true }]` | | Table | A flat list with one entry per column, in column order: `["Widget", "3"]` | | Assignees | `{ "users": [12345], "guests": ["guest@example.com"], "groups": ["group_id"] }` | | File/Image | A list of file objects. See [Attach files using the API](/products/pro/integrations/open-api/code-samples/files/upload-attach-file/) - files must be uploaded first. | Three shapes catch people out: - **Radio and dropdown look identical in the app but differ here.** A radio takes the bare option text. A dropdown needs the `id` and `text` pair together, and the `text` has to match the option exactly. - **Every chosen multi-select option needs `"selected": true`.** Without it the value still saves and you still get a `200`, but the field renders as empty text wherever it's used as a `{{variable}}`. A blank multi-select in a task description or an email is nearly always a missing `selected` flag. - **A table takes one entry per column, not per row.** Send a different number of entries and the request fails with `Number of columns does not match required columns`. :::caution[An unknown key fails silently] Tallyfy matches every `taskdata` key against the task's form field timeline IDs. A key that matches nothing is dropped without an error, so the request still returns `200 OK` with that field unchanged. If a value doesn't stick, check your keys before anything else. ::: #### Multiple field types in one 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] Don't know the Form Field IDs? Two options: 1. Call the [Get Task](/products/pro/integrations/open-api/code-samples/tasks/get-task/) endpoint with `?with=form_fields`. 2. Open browser dev tools and watch network requests while interacting with the form in Tallyfy's UI. ::: ### Updating assignees with `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[Owners replace - they don't merge] The `owners` object *replaces* all existing assignees with the ones you specify. To remove all assignees, pass empty arrays for all three keys. If you need to add someone without removing others, first fetch the current task to get existing assignees, then send the full combined list. ::: ### Code samples ## Response Returns `200 OK` with the full task object after the update, wrapped in a `data` envelope. ```json { "data": { "id": "TASK_ID_TO_UPDATE", "title": "Go Updated Task Title", "status": "active", "owners": { "users": [{ "id": 1005, ... }], "groups": [], "guests": [] }, "deadline": "2025-07-01T09:00:00Z", "started_at": "2025-06-01T09:00:00Z", "last_updated": "2025-05-20T16:00:00Z", "taskdata": { "text_field_id_example": "Updated value from JS", "dropdown_field_id_example": { "id": 3, ... }, "radio_button_field_id": "Option B" }, "webhook": null, "prevent_guest_comment": false, "position": 1, "is_oneoff_task": false } } ``` Note that `summary` only appears in the response when you fetch a single task (not in list responses), or when you include `?with=summary`. Completed tasks can't be updated - you'll get a validation error. Other error codes: `404` (task not found), `403` (no permission), `422` (validation failure - wrong field type, missing required fields). --- ### Tags - **[Delete tag](https://tallyfy.com/products/pro/integrations/open-api/code-samples/tags/archive-tag/)**: Tallyfy's DELETE API endpoint at `/organizations/{org_id}/tags/{tag_id}` permanently removes a tag and all its associations with templates and processes and steps and tasks in an irreversible operation that returns a 204 No Content response on success. {/* ACCURACY_CHECK: Filename is archive-tag.mdx but content describes deleting a tag, not archiving */} ## Endpoint `DELETE /organizations/{org_id}/tags/{tag_id}` This permanently deletes a tag and removes all its associations with templates, processes, steps, and tasks. This action can't be undone. ## Request Replace `{org_id}` with your Organization ID and `{tag_id}` with the tag's ID. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Body You don't need a request body. ### Code samples ## Response A successful delete returns `204 No Content` with an empty response body. The tag and all its associations are permanently removed. If the tag ID doesn't exist, the endpoint still returns `204` -- it won't error on a missing tag. --- - **[Create tag](https://tallyfy.com/products/pro/integrations/open-api/code-samples/tags/create-tag/)**: Tallyfy's API lets you create organization tags by sending a POST request to the tags endpoint with a required title (up to 30 characters) and an optional hex color code. It returns the new tag's ID and details with a 201 status. ## Endpoint `POST /organizations/{org_id}/tags` Creates a new tag in 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) | Field | Type | Required | Description | |-------|------|----------|-------------| | `title` | string | Yes | Tag name. Must be unique within the org. Can't exceed 30 characters. | | `color` | string | No | Hex color code, exactly 7 characters (e.g., `#3498db`). | ```json { "title": "High Priority", "color": "#e74c3c" } ``` ## Code samples ## Response You'll get a `201 Created` status with a JSON object containing the new tag's details. ```json { "data": { "id": "new_tag_id_xyz", "title": "Python Tag", "color": "#f1c40f", "auto_generated": false, "created_at": "2024-03-15T10:30:00Z", "deleted_at": null } } ``` Save the returned `id` to update or delete this tag later. --- - **[Get tag](https://tallyfy.com/products/pro/integrations/open-api/code-samples/tags/get-tag/)**: Retrieve a specific tag by its ID using a GET request to `/organizations/{org_id}/tags/{tag_id}`. Optionally include usage statistics showing how many active or archived templates and processes use that tag. ## Endpoint `GET /organizations/{org_id}/tags/{tag_id}` Fetches a single tag by its ID within your organization. ## Request Replace `{org_id}` with your Organization ID and `{tag_id}` with the tag's ID. ### Headers - `Authorization: Bearer {your_access_token}` - `Accept: application/json` - `X-Tallyfy-Client: APIClient` ### Query parameters (optional) - `with` (string): Set to `statistics` to include usage counts (active/archived templates and processes). ### Code samples ## Response A successful request returns a `200 OK` status and a JSON object with the tag details inside `data`. ```json { "data": { "id": "TAG_ID_TO_GET", "title": "Urgent", "color": "#e74c3c", "auto_generated": false, "created_at": "2024-01-15T10:00:00Z", "deleted_at": null, "statistics": { "data": { "active_template": 5, "archived_template": 2, "active_process": 12, "archived_process": 3 } } } } ``` The `statistics` object only appears when you pass `with=statistics`. If the tag isn't found or you don't have access, you'll get a `404` or `403` error. --- - **[List tags](https://tallyfy.com/products/pro/integrations/open-api/code-samples/tags/list-tags/)**: Retrieve all tags in your organization with optional name filtering and pagination. You can also request usage statistics showing how many templates and processes each tag is associated with. ## Endpoint `GET /organizations/{org_id}/tags` Retrieves all tags in 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) - `q` (string) - Search by tag name. - `with` (string) - Include related data. Supported value: `statistics`. - `all` (string) - Set to `true` to include auto-generated process tags, which aren't returned by default. - `per_page` (integer) - Tags per page. Defaults to `10`. - `page` (integer) - Page number for pagination. - `sort` (string) - Sort by a property. Prefix with `-` for descending order. ### Code samples ## Response You'll get a `200 OK` response with a JSON object containing a `data` array of tags and `meta` pagination info. Each tag object contains these fields from the TagTransformer: `id`, `title` (max 30 chars), `color`, `auto_generated`, `created_at`, and `deleted_at`. If you've requested `with=statistics`, each tag also includes a nested `statistics` object with: `active_template`, `archived_template`, `active_process`, and `archived_process` counts. ```json { "data": [ { "id": "tag_id_abc", "title": "Urgent", "color": "#e74c3c", "auto_generated": false, "created_at": "2025-01-15T10:00:00Z", "deleted_at": null, "statistics": { "data": { "active_template": 5, "archived_template": 2, "active_process": 12, "archived_process": 3 } } } ], "meta": { "pagination": { "total": 25, "count": 10, "per_page": 10, "current_page": 1, "total_pages": 3 } } } ``` --- - **[Update tag](https://tallyfy.com/products/pro/integrations/open-api/code-samples/tags/update-tag/)**: Modify an existing tag's title (up to 30 characters, unique per organization) or hex color code by sending a PUT request to `/organizations/{org_id}/tags/{tag_id}`. Includes code samples in JavaScript, Python, Java, Go, C++, and C#. ## Endpoint `PUT /organizations/{org_id}/tags/{tag_id}` Updates the title or color of an existing tag. ## Request Replace `{org_id}` with your organization ID and `{tag_id}` with the tag ID to update. ### Headers | Header | Value | |---|---| | `Authorization` | `Bearer {your_access_token}` | | `Accept` | `application/json` | | `X-Tallyfy-Client` | `APIClient` | | `Content-Type` | `application/json` | ### Body (JSON) Send a JSON object with the fields you want to change. | Field | Type | Required | Description | |---|---|---|---| | `title` | string | Yes | Tag name (max 30 characters, must be unique within your organization) | | `color` | string | No | Hex color code (e.g. `#ff0000`) | **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 with the updated tag. ```json { "data": { "id": "TAG_ID_TO_UPDATE", "title": "Python Updated Tag", "color": "#34495e", "auto_generated": false, "created_at": "2024-01-15T10:30:00.000Z", "deleted_at": null } } ``` If the tag ID isn't found or the payload fails validation, expect a `404`, `422`, or `400` error. --- ### Middleware - **[Connector capability matrix](https://tallyfy.com/products/pro/integrations/middleware/connector-capability-matrix/)**: Every Tallyfy middleware connector (Zapier, Power Automate, Workato, Celigo, Make.com, and n8n) now covers the same core action set across ten categories, plus polling triggers that work everywhere today and instant (webhook) triggers that push events in real time. This page maps what each connector can do and links to every setup guide. ## The same core actions across every connector Tallyfy has prepared one common action set across all six middleware connectors, so whichever platform you end up on, you get the same building blocks for tasks, processes, templates, forms, and more. :::note[Not every connector is available yet] Live today: **Zapier**, **Power Automate**, **n8n**, **Make**, and **Celigo**. Make's and Celigo's official Tallyfy connectors are built and maintained by those vendors, not by Tallyfy: Make is live on [Make's marketplace](https://www.make.com/en/integrations/tallyfy), and Celigo maintains a prebuilt Tallyfy connector inside [integrator.io](https://docs.celigo.com/hc/en-us/articles/15109930461979-Set-up-a-connection-to-Tallyfy) that supports both an API token and OAuth 2.0. Still rolling out: **Workato** is built but not yet published to its marketplace, so you can't install it that way yet. Contact [Tallyfy support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/) for early access to Workato, or use any vendor's HTTP module with [Tallyfy's REST API](/products/pro/integrations/open-api/) today. The prepared counts in the table below are Tallyfy's target set; for Make and Celigo they include a proposed expansion beyond the vendors' current live modules, so what you see inside a given platform today may be smaller. Check each connector's own guide for its current state. ::: ### What every connector will cover The shared set spans ten action categories. Each maps to real Tallyfy REST API capabilities. | Category | What it covers | |---|---| | **Users and guests** | Invite members, read and list users, change roles, enable or disable accounts, create and update guests | | **Groups** | Create, read, update, and delete groups | | **Tasks** | Create standalone tasks, complete tasks (including approvals), update, reopen, and read tasks; list your tasks or a process's tasks | | **Processes** | Launch a process from a template, read, update, archive, reactivate, and list processes | | **Templates** | Read, list, create, clone, update, and delete templates; manage kick-off form fields | | **Form fields** | Add, update, move, delete, and reorder step form fields and kick-off fields | | **Comments and issues** | Add comments, edit or delete comments, report an issue on a task, and resolve an issue | | **Tags** | Create, update, and delete tags; tag or untag templates and processes | | **Folders** | Create, update, and delete folders; move templates and processes in and out of folders | | **Search** | Keyword search across tasks, processes, templates, snippets, or everything at once | :::note[Not in this round (planned follow-up)] Three capability areas are a later (Tier 2) follow-up and are not part of this expansion: automation rules (if-this-then-that rules built on a template), step-level template edits (adding, deleting, cloning, reordering, or reassigning individual steps), and the optional raw API passthrough action. Until then, use the [Open API](/products/pro/integrations/open-api/) directly for those. ::: ### Two kinds of triggers Every connector offers the same triggers in two flavors. Polling triggers work everywhere today. Instant (webhook) triggers push events the moment they happen: they are live in Zapier and n8n, built into the Workato and Power Automate connectors, and part of the prepared Celigo and Make sets. **Polling triggers** check Tallyfy on a schedule (typically every few minutes) and de-duplicate by record id, so you never see the same item twice. That is near real time, not instant. The shared polling set: 1. **New process launched** - fires when a process starts, optionally scoped to one template. 2. **Task completed** - fires when a task is marked complete. 3. **Task assigned to you (new task)** - fires when a new task lands in your queue. 4. **Comment or issue added** - fires when a comment or a reported issue appears on a watched task or process. Workato adds a fifth polling trigger, **Process completed**, which fires when a whole process reaches completed status. #### Instant (webhook) triggers Instant triggers skip the wait. Tallyfy pushes each event to your connector the moment it happens, so a Zap, recipe, or flow starts in real time instead of on the next poll. The connector registers one organization-wide webhook subscription through Tallyfy's watcher API, and Tallyfy posts every event to it. Two things to know before you rely on them: - **They need an organization admin connection.** Registering an organization webhook requires an admin account. Connect as a non-admin and Tallyfy returns a permission error, so use the matching polling trigger instead. - **They depend on Tallyfy's organization-webhook backend, which is rolling out.** The triggers ship in the connectors, but the backend that delivers the events is still reaching every production organization. Until yours has it enabled, an instant trigger may not fire. Use the polling trigger meanwhile, then switch once it is on. The events fire on the same moments across connectors: a process is launched or completed, a task is completed or assigned, and a comment or issue is added or resolved. What each connector calls them: | Connector | Instant (webhook) triggers | |---|---| | Zapier | New Process Launched, Process Completed, New Task Assigned, Task Completed, New Comment or Issue on a Task (5 triggers, live) | | n8n | One Tallyfy Trigger node in Instant (Webhook) mode, covering 7 events: process launched, process completed, task completed, task assigned, comment added, issue raised, issue resolved (live) | | Workato | New process launched, Process completed, Task completed, New task assigned, New comment or issue (5 triggers, built) | | Power Automate | Process launched, Process completed, Task completed, Task assigned, Comment or issue (5 triggers built, awaiting Microsoft certification) | | Celigo | Process launched, process completed, task assigned, task completed, comment or issue (5 webhook flows) | | Make.com | New Process Launched, Process Completed, Task Completed, New Task Assigned, New Comment or Issue (5 triggers) | ## Coverage by connector The counts below are each platform's own native operation unit for the prepared set. One Tallyfy action can appear as several native operations (or the reverse), so the raw numbers are not identical across platforms. What matters is that every connector is being brought to the same capability categories and the same core triggers listed above. Zapier and n8n already expose their full prepared set. Power Automate is live too, but only with its original certified set (13 actions, no triggers); its expanded set below is built and waiting on Microsoft certification, so it is not in the published connector yet. | Connector | Status | Prepared actions | Triggers | Authentication | Setup guide | |---|---|---|---|---|---| | n8n | Live | 96 operations across 12 resources | 4 polling + instant (7 events) | OAuth 2.0 | [n8n guide](/products/pro/integrations/middleware/n8n/) | | Zapier | Live | 52 create plus 28 search actions | 4 polling + 5 instant | OAuth 2.0 | [Zapier guide](/products/pro/integrations/middleware/zapier/) | | Power Automate | Live (original set) | 83 built, 13 live today | 4 polling + 5 webhook built, 0 live yet | OAuth 2.0 | [Power Automate guide](/products/pro/integrations/middleware/power-automate/) | | Workato | In development | 82 actions | 5 polling + 5 instant | OAuth 2.0 | [Workato guide](/products/pro/integrations/middleware/workato/) | | Celigo | Live (Celigo-maintained); expansion proposed | 86 flows prepared; live set is smaller | 4 polling + 5 instant | API token or OAuth 2.0 | [Celigo guide](/products/pro/integrations/middleware/celigo/) | | Make.com | Live (Make-maintained); expansion proposed | 90 modules prepared (81 actions plus 4 polling and 5 instant triggers); live set is smaller | 4 polling + 5 instant | Tallyfy API token | [Make guide](/products/pro/integrations/middleware/make/) | Make's and Celigo's official connectors are built and maintained by those vendors, not by Tallyfy, and are live today; the fuller module sets in the table above are a proposed expansion Tallyfy would coordinate with each vendor, not a self-serve publish. Once Workato is published too, all six will cover the same core actions, so you can pick the platform that best fits the rest of your stack rather than choosing on Tallyfy coverage alone. If you need something that works today, Zapier, n8n, Make, and Celigo already give you a working connector, and Power Automate ships its original certified actions. For help deciding, see [why use an integration platform](/products/pro/integrations/middleware/why-should-i-use-an-integration-platform-with-tallyfy/). ## AI-native access (Tallyfy MCP) If you would rather skip point-to-point connectors, the Tallyfy MCP server lets an AI assistant (ChatGPT, Claude, Gemini, or Microsoft Copilot) call these same actions in plain English, with no recipe to build. It exposes more than 100 Tallyfy tools and respects your existing permissions on every action. See the [MCP server](/products/pro/integrations/mcp-server/) guide, or [BYO AI](/products/pro/integrations/byo-ai/) for the simplest setup using an AI subscription you already pay for. - **[Stream data to a spreadsheet](https://tallyfy.com/products/pro/integrations/middleware/how-can-i-export-form-fields-from-tallyfy-to-spreadsheet/)**: Tallyfy can automatically send completed form field data to Google Sheets or Excel Online by firing a webhook when a task is done and using middleware tools like Zapier or Power Automate to map each field value into the correct spreadsheet columns without any manual copying. ## Export form fields to spreadsheets automatically When a task's completed in Tallyfy, a [webhook](/products/pro/integrations/webhooks/) fires with all [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) responses included in the payload. [Middleware](/products/pro/integrations/middleware/) platforms like Zapier, Make, or Power Automate catch that payload and push it into Google Sheets or Excel Online. There's no manual copying needed. ### Why export form data to spreadsheets? - **One place for all responses** - every completed form lands in a single spreadsheet automatically - **Reporting ready** - build charts and dashboards with Excel or Google Sheets' built-in tools - **Audit trail** - each submission gets logged permanently for compliance - **Data hub** - spreadsheets connect to almost everything else your team uses ### Pick a middleware tool - **Zapier** - easiest to start with, lots of pre-built connections - **Microsoft Power Automate** - best fit if you're already on Microsoft 365 - **Make.com** - more powerful for complex workflows, steeper learning curve - **Custom code** - connect directly using Tallyfy [webhooks](/products/pro/integrations/webhooks/) and the [API](/products/pro/integrations/open-api/) for full control ### General setup steps ### Video example using Zapier This video walks through Zapier setup. The same principles apply to other middleware tools: - **[CRM and ERP integration](https://tallyfy.com/products/pro/integrations/middleware/integrate-into-crm/)**: Tallyfy connects to CRM and ERP systems like Salesforce and NetSuite through middleware or magic links. It automates the invisible micro-tasks between pipeline stages that CRMs can't track or coordinate across departments. ## Connecting Tallyfy to your CRM or ERP Tallyfy connects to CRM systems (Salesforce, HubSpot, Dynamics 365, etc.) and ERP systems (NetSuite, SAP, etc.) so you can link sales or operational stages with detailed workflows that run in Tallyfy. ### Why connect? - **Save on licenses** - run operational workflows in Tallyfy instead of buying CRM/ERP seats for everyone involved. - **Consistent processes** - teams follow standard procedures even when people outside the CRM/ERP are involved. - **Smooth handoffs** - transitions between teams (Sales to Operations) become trackable. - **Better client experience** - clients get a consistent journey from first contact through delivery. ### The gap between CRM stages CRMs track deals through stages - Lead, Qualified, Proposal, Negotiation, Closed Won. What they miss: the dozens of micro-tasks that must happen between each stage transition. These invisible tasks determine whether deals progress or stall. When a deal moves from "Qualified" to "Proposal," it's not one click - it's technical reviews, pricing approvals, legal checks, resource allocation, and demo preparation. Each involves multiple people, deadlines, and conditional logic based on deal characteristics. Tallyfy makes these micro-tasks visible, trackable, and automatic. Your CRM shows the big picture; Tallyfy handles every critical step between stages. ### What CRMs can't do (but Tallyfy can) CRMs store customer data and track sales activities well, but they fall short for operational workflows. #### Inflexible task sequences CRMs force rigid, linear task flows. Need different onboarding steps based on deal size or service type? You're stuck with workarounds. Tallyfy's [conditional automations](/products/pro/documenting/templates/automations/conditionals/) show or hide steps based on form answers automatically. #### No auto-assignment or deadline tracking Most CRMs require daily logins to check for pending tasks. Tallyfy auto-assigns tasks to the right people, sends deadline reminders, and escalates overdue items. #### Fragmented collaboration CRMs work for sales teams, but what about Legal, Finance, or external partners? Tallyfy lets you involve internal [members](/products/pro/documenting/members/) or external [guests](/products/pro/documenting/guests/) in the same workflow - everyone sees their tasks and deadlines. #### Weak audit trails CRMs track data changes but don't record who did what task, when, and in what order. Every Tallyfy [process](/products/pro/tracking-and-tasks/processes/) creates a complete audit trail automatically - who did what, when, and in what sequence. #### Disconnected tools CRMs can't coordinate workflows across multiple systems. Tallyfy connects tools through [middleware](/products/pro/integrations/middleware/) for end-to-end processes. ### Example micro-tasks between CRM stages #### Lead to MQL Converting a lead to MQL involves tasks CRMs don't track - researching company fit, verifying contact info, checking for existing customer conflicts, scoring engagement, and enriching data. Tallyfy launches this workflow automatically when a new lead enters your CRM. Each task has an owner and deadline, and the lead only advances when all tasks complete. #### MQL to SQL Moving to sales-qualified triggers tasks like scheduling discovery calls, preparing talking points, identifying decision makers, and checking credit history. Without Tallyfy, these happen inconsistently or not at all. #### SQL to opportunity Creating an opportunity requires defining solution requirements, estimating timelines, calculating pricing, and assessing the competition. Tallyfy's conditional logic adjusts the workflow based on deal size - enterprise deals automatically add security reviews and legal pre-approval. #### Opportunity to closed won The most critical transition: generating contracts, obtaining pricing approval, coordinating signatures, creating implementation projects, scheduling kickoff calls, and provisioning access. Each task must complete in sequence with the right person. CRMs just show "Closed Won" while the real work happens elsewhere. ### Common connection examples #### Lead management - New CRM lead? Auto-launch a lead qualification process in Tallyfy. - Assign research and contact tasks in Tallyfy, then push updates back to the CRM record. #### Sales stage changes - Deal moves to "Proposal Sent"? The matching Tallyfy process (e.g. "Contract Review") starts automatically. - Include people who don't use the CRM (Legal, Finance) in the right steps. #### Client onboarding - Deal marked "Won"? A client onboarding process launches in Tallyfy instantly. - Hand off to implementation or customer success teams, and invite the client as a guest for specific tasks. #### Standardizing support - Manage multi-step support procedures in Tallyfy so agents follow consistent steps every time. ### Why micro-task visibility matters Two deals might both show "Proposal Stage" in your CRM, but their realities differ: **Without Tallyfy:** Proposal sent without technical review. Pricing approved verbally. Implementation team not consulted. Legal review skipped. **With Tallyfy:** Technical review completed. Pricing approved in writing. Implementation confirmed availability. Legal pre-approved terms. Both deals look identical in the CRM, but the second one closes faster with fewer surprises because every micro-task between stages was tracked and completed. ### How to connect using middleware or links Most connections use [middleware](/products/pro/integrations/middleware/) platforms (Zapier, Make, Power Automate). Direct links work too. :::note[Choosing middleware] Zapier works for simple connections. For more advanced setups, consider Make.com or Power Automate. Developers can use the Tallyfy API for full control. ::: ![Tallyfy Salesforce widget integration](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, from CRM to Tallyfy and back, so updates hit the correct record. - **Middleware as the bridge** - middleware handles data transformation between Tallyfy's webhook format and your CRM's API. - **Two distinct flows** - launching Tallyfy processes from your CRM vs. updating CRM records from Tallyfy. You can implement either or both. Here's how information flows between systems: #### 1. Start Tallyfy processes from your CRM/ERP Use a [magic link](/products/pro/launching/triggers/magic-links/) to create a button or link inside your CRM/ERP. 1. Create a 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 within your CRM/ERP interface - typically on the Opportunity page. 4. When a user clicks, Tallyfy starts the process with all CRM/ERP data pre-filled. Watch it in action: #### 2. Send Tallyfy form data to your CRM/ERP Update CRM/ERP records with information collected in Tallyfy forms: 1. Set up a Tallyfy [webhook](/products/pro/integrations/webhooks/) to trigger when a specific task gets completed. 2. Use a middleware tool to catch the webhook data. 3. Configure middleware to find the correct CRM/ERP record (using an ID passed from the CRM initially) and update fields with Tallyfy form answers. **Important**: To update the right record in your CRM/ERP, you need that record's unique ID. Pass this ID from the CRM/ERP into Tallyfy when the process starts (using the magic link method above), then use it later to find the right record to update. - **[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 connect Tallyfy to hundreds of apps without custom API code. Pre-built connectors, error handling, and data transformation tools get integrations running in minutes instead of days. ## Why use middleware platforms instead of custom API code? Middleware tools like Zapier, Make, or Power Automate beat custom API code for most Tallyfy integrations. They save you development time and ongoing maintenance headaches. ### What does an integration platform do? Think of middleware as a universal translator between Tallyfy and your other apps. You get: - Ready-made connections to hundreds of popular apps - Data transformation between Tallyfy's format and other apps - Automatic error handling and retries when connections fail - Monitoring dashboards for all your connections - Visual interfaces - no code required (usually) Tallyfy has built connectors for Microsoft Power Automate, Zapier, Make.com, and Workato. :::note[Choosing a tool] Zapier works fine for basic automations. For complex logic, **Make.com** or **Microsoft Power Automate** are stronger choices. Developers who want full 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. With middleware, you're protected: - **Less work for you**: When Tallyfy updates its API, the middleware company fixes their connector. It's not your problem anymore - **Version handling**: The platform manages API version differences behind the scenes - **Ongoing support**: Your connections keep working as apps evolve #### 2. Faster setup with pre-built connectors Middleware gets you running in minutes instead of days: - **Large libraries**: 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 required. #### 3. More ways to start workflows - **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 actions across them #### 4. Built-in tools you don't have to build Here's what 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**: Credentials stored safely, connections managed properly ### Recommended approach If you have custom requirements, 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 error handling, monitoring, and maintenance You get the flexibility of custom code without maintaining everything yourself. ### Which platform to choose? Each platform has its sweet spot: - **Microsoft Power Automate**: Already using Microsoft 365? This integrates directly. - **Zapier**: Dead simple to start with. Good for your first automation. - **Make.com**: Best for complex data transformations and branching logic. - **Workato**: Enterprise-grade features for larger organizations. - **[Celigo](https://tallyfy.com/products/pro/integrations/middleware/celigo/)**: Celigo's integrator.io platform has an official, Celigo-maintained Tallyfy connector, selectable natively when you build a flow and supporting both an API token and OAuth 2.0. Use it to trigger approvals from NetSuite orders or sync task completions to your ERP and CRM systems. ## Connecting Tallyfy with Celigo :::note[Available today in Celigo] Celigo maintains an official prebuilt Tallyfy connector inside integrator.io, so you can connect the two today. You select it natively when you build an export, import, or flow step, and it supports both a Tallyfy API token and OAuth 2.0. Celigo documents the setup in their Help Center: [set up a connection to Tallyfy](https://docs.celigo.com/hc/en-us/articles/15109930461979-Set-up-a-connection-to-Tallyfy) and [set up an OAuth 2.0 connection](https://docs.celigo.com/hc/en-us/articles/15393858597147-Set-up-an-OAuth-2-0-connection-to-Tallyfy). For any endpoint the connector doesn't cover yet, use Celigo's universal HTTP connector with [Tallyfy's REST API](/products/pro/integrations/open-api/). Contact [Tallyfy support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/) if you need OAuth credentials. ::: Celigo's integrator.io platform connects enterprise systems, particularly NetSuite, Salesforce, and other business applications. You can use it to create data flows between Tallyfy and your other systems through Tallyfy's REST API. ### What you can do with a Celigo-Tallyfy integration Typical integration patterns include: 1. **Trigger processes from business events** - a sales order in NetSuite launches an approval workflow in Tallyfy 2. **Sync task completions** - completed Tallyfy tasks update records in connected systems through Celigo flows 3. **Keep data in sync** - process data stays current across Tallyfy, your ERP, CRM, and other platforms 4. **Automate assignments** - use Celigo's data transformations to assign Tallyfy tasks based on business rules ### Using the HTTP connector for anything beyond the native connector The native Celigo connector covers the common actions. For an endpoint it doesn't cover, use Celigo's universal HTTP connector to call Tallyfy's API directly. **Steps to connect:** 1. Create a new HTTP connection in Celigo 2. Configure authentication using a Tallyfy API token or OAuth 2.0 credentials 3. Map Tallyfy's REST API endpoints for templates (called "checklists" in the API) and processes (called "runs" in the API) 4. Build flows using Celigo's visual interface **Key Tallyfy API endpoints you'll use:** All endpoints are scoped to an organization: `/organizations/{org_id}/...` - `GET .../checklists` - list available process templates - `POST .../runs` - launch a new process from a template - `GET .../runs/{run_id}/tasks` - get tasks in a running process - `POST .../tasks` - create standalone tasks - `PUT .../runs/{run_id}/tasks/{task_id}` - update or complete a task **API terminology mapping:** - "Templates" in the UI = "Checklists" in the API - "Processes" in the UI = "Runs" in the API ### Authentication options **Personal access token** - the quickest way to start. Go to Settings > Integrations > REST API in Tallyfy and copy your token. It acts on behalf of your user account. **OAuth 2.0** - better for production integrations where multiple users authorize access. Contact Tallyfy support to get a Client ID and Client Secret. Tallyfy supports OAuth 2.0 bearer tokens with refresh capability. ### Example scenarios **Order-to-fulfillment:** A high-value order in NetSuite triggers a Tallyfy approval process through Celigo. Each approval step in Tallyfy updates the order status back in NetSuite. **Employee onboarding:** New employee records in your HRIS trigger onboarding processes in Tallyfy. Celigo moves data between HR systems, IT provisioning tools, and Tallyfy tasks. **Customer escalation:** Support tickets hitting priority thresholds in your CRM launch escalation workflows in Tallyfy through Celigo flows. ### Celigo developer program Celigo lets third-party developers create and publish connectors through their developer program. If you want to build a reusable Tallyfy connector, you can: - Enroll in Celigo's Third-Party Developer Program - Build custom integration apps using Tallyfy's REST API - Package and publish solutions to Celigo's marketplace - Go through Celigo's certification process for marketplace listing ### Requirements **On the Tallyfy side:** - API access enabled for your organization - REST API token or OAuth credentials - Process templates ready with the fields you want to populate **On the Celigo side:** - integrator.io account with appropriate licensing - Universal connector permissions enabled - Error handling and retry rules configured - **[Make](https://tallyfy.com/products/pro/integrations/middleware/make/)**: Make (formerly Integromat) has an official, Make-maintained Tallyfy connector, live on Make's marketplace today, to launch processes, complete tasks, and sync form data. Add it from inside Make, or use Make's HTTP module with Tallyfy's REST API for anything beyond it. ## Visual workflow automation with Make Make (formerly Integromat) is a visual [integration](/products/pro/integrations/) platform that connects Tallyfy with hundreds of business applications. You build scenario-based workflows to automate multi-step [processes](/products/pro/tracking-and-tasks/processes/) across your apps - no coding required. For more on workflow automation, see the [workflow automation guide](https://tallyfy.com/workflow-automation/). :::note[Available today on Make] Make maintains an official Tallyfy connector, live and verified on Make's marketplace. You can add it from inside Make right now at [make.com/en/integrations/tallyfy](https://www.make.com/en/integrations/tallyfy). Make built this connector from Tallyfy's public API, so its module set is defined and maintained by Make. For anything the connector does not cover yet, you can still use Make's built-in HTTP module with [Tallyfy's REST API](/products/pro/integrations/open-api/), as shown below. ::: Make's official Tallyfy connector covers core actions like these: - **Start process** - [Launch](/products/pro/launching/) a new process from any template, with kick-off form data - **Complete task** - Mark [tasks](/products/pro/tracking-and-tasks/tasks/) as done and submit [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) data - **Update task** - Change task name, deadline, or assignees (members, guests, groups) - **Add comment** - Post comments or report problems on tasks - **Get process / List tasks** - Pull process details or retrieve your assigned tasks - **Watch new tasks** - Webhook trigger that fires when tasks get assigned to you ### Why use Make with Tallyfy? - **Visual debugging** - See exactly how data flows through each scenario step - **Built-in error handling** - Automatic retries and error routes keep things running - **Data transformation** - Built-in functions reshape data between steps - **Flexible scheduling** - Run scenarios on demand, on a 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/) finish ### Using Make's HTTP module for anything beyond the connector The official connector handles the common actions. For an endpoint it does not expose, use Make's built-in **HTTP** module to call [Tallyfy's REST API](/products/pro/integrations/open-api/) directly. This covers the same launch, complete, and update actions, wired by hand: 1. Create a Make account at make.com. 2. Add an **HTTP** module to your scenario. 3. Authenticate with your Tallyfy API token and Organization ID, both found in **Settings > Integrations > REST API**. 4. Point each request at the [Tallyfy API endpoint](/products/pro/integrations/open-api/) you need, then map your data into it. 5. Test with sample data, then activate the scenario. For the common actions, the official Make-maintained connector already handles this wiring for you. Use the HTTP module for anything it does not yet cover. - **[n8n](https://tallyfy.com/products/pro/integrations/middleware/n8n/)**: n8n is a developer-friendly automation platform with a dedicated Tallyfy connector. It offers 96 operations across 12 resources plus a Tallyfy Trigger node, and connects Tallyfy to hundreds of business apps with self-hosting support. ## What is n8n and how does it work with Tallyfy? n8n connects Tallyfy with hundreds of business applications through visual workflows. It's a developer-friendly alternative to Zapier and Make, with strong AI and LLM support baked in. You can self-host for full control or use their cloud service. For a broader perspective on automation strategies, see our guide on [how to automate business processes](https://tallyfy.com/automate-business-processes/). ![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) Tallyfy has a dedicated n8n connector with 96 operations across 12 resources - blueprints, processes, tasks, form fields, comments, users, guests, groups, tags, folders, search, and ID finder - plus a dedicated **Tallyfy Trigger** node that starts workflows on Tallyfy events. You can also use n8n's 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. You can combine traditional automation with LLM capabilities in a single workflow, and write JavaScript or Python code directly when visual building isn't enough. ::: ### Key advantages of n8n for Tallyfy integration | Feature | Benefit for Tallyfy users | |---------|---------------------------| | **Dedicated Tallyfy connector** | 96 operations across blueprints, processes, tasks, users, and more, plus a Tallyfy Trigger node - 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 security, compliance, and cost control | | **Visual workflow builder** | Drag-and-drop multi-system integrations | | **Code when needed** | Add JavaScript or Python for advanced logic | | **Hundreds of integrations** | Connect Tallyfy to CRM, ERP, communication tools, and other business systems | | **Enterprise-ready** | Advanced permissions, SSO, air-gapped deployments | | **Execution-based pricing** | A 100-node workflow costs the same as a 5-node one - no per-node charges | ### Common Tallyfy + n8n integration scenarios 1. **Intelligent process launching** - Launch Tallyfy processes when conditions are met across multiple systems. Use AI to analyze incoming requests and start the right workflow automatically. 2. **AI-enhanced data processing** - Analyze form responses with LLMs, categorize processes based on content, or generate summaries of completed workflows. 3. **Cross-system orchestration** - Synchronize data between Tallyfy and other business systems in real-time. Build approval chains that span multiple platforms. 4. **Advanced automation patterns** - Route processes through different paths with conditional logic. Set up automatic escalation when deadlines approach. 5. **Document and reporting automation** - Generate contracts and reports from completed process data. Archive processes to document management systems automatically. ### Getting started with n8n and Tallyfy ### Technical implementation approaches **Option 1: Dedicated Tallyfy connector** The easiest approach - install the community-built n8n node (`n8n-nodes-tallyfy`) with 96 pre-configured operations: - **Authentication**: Access token and organization ID - **Operations**: Launch processes, manage tasks, update form fields, handle users and guests - **Resource coverage**: Blueprints, processes, tasks, form fields, comments, users, guests, groups, tags, folders, search, and ID finder **Option 2: HTTP Request node** For custom integrations or advanced use cases: - **Authentication**: Bearer token with your Tallyfy access token - **Base URL**: `https://go.tallyfy.com/api/` - **Content Type**: `application/json` - **Methods**: GET, POST, PUT, DELETE **Real-time updates via webhooks** Set up the Webhook node to receive notifications from Tallyfy when tasks complete, processes update, or forms are submitted. Configure your webhook URL in Tallyfy's settings and n8n handles the rest. :::note[Handling files in n8n] When working with file uploads from Tallyfy forms, n8n can process binary data and send files to cloud storage like Google Drive, Dropbox, or S3. Built-in nodes handle images, PDFs, and other file types as part of your workflow. ::: ### Deployment and enterprise options **Cloud vs. self-hosted:** | Use case | Recommended option | Why | |----------|-------------------|-----| | Quick testing, small teams | n8n Cloud | Zero setup, automatic updates | | Enterprise compliance | Self-hosted | Full data control, air-gapped deployment | | High-volume processing | Kubernetes | Horizontal scaling, fault tolerance | | Cost optimization | Docker self-hosted | Predictable costs, no per-execution charges | **Self-hosting options:** Docker (single-command deployment), Kubernetes (high availability), npm/Node.js (direct install), or air-gapped for sensitive environments. **Enterprise features:** Role-based access control, SSO with major identity providers, audit logging, and priority support with SLA guarantees. For organizations with strict compliance needs, self-hosting keeps your Tallyfy integration data entirely on your own infrastructure. Explore the articles below for detailed setup instructions and specific integration examples. - **[Power Automate](https://tallyfy.com/products/pro/integrations/middleware/power-automate/)**: Microsoft Power Automate connects Tallyfy to Office 365, SharePoint, Dynamics, and other business systems. Its Premium-tier OAuth 2.0 connector provides 13 actions to sync data and launch processes automatically. Microsoft Power Automate (formerly Flow) connects your Tallyfy [processes](/products/pro/tracking-and-tasks/processes/) with Microsoft tools and other business applications. For background on what Power Automate can do, see our [Power Automate explainer](https://tallyfy.com/what-is-microsoft-flow-power-automate/). It acts as the bridge that lets Tallyfy talk to your other systems, automating data flows between them. Tallyfy handles defining, managing, and tracking human-centric [processes](/products/pro/tracking-and-tasks/processes/). Power Automate complements this by handling the system-to-system integrations and automated actions that happen around your Tallyfy workflows -- no coding required. The official Tallyfy connector for Power Automate is a Premium tier connector that uses OAuth 2.0 authentication. It provides 13 actions (and no triggers) for managing processes, tasks, members, and guests directly from your flows. :::note[An expanded connector is on the way] Tallyfy has built a larger Power Automate connector with many more actions and the same triggers as Tallyfy's other connectors - four polling triggers plus five instant (webhook) triggers (see the [connector capability matrix](/products/pro/integrations/middleware/connector-capability-matrix/)). It is not yet submitted for Microsoft certification, so the published connector today is the 13-action, no-trigger set described here. [Contact Tallyfy support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/) for early access or a heads-up when it ships. ::: | 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 | Combining Power Automate with Tallyfy gives you: * **Data synchronization** -- Keep information consistent between Tallyfy and other business systems without double entry. * **Automated flows** -- Use Power Automate flow triggers (like a new email or SharePoint event) to launch Tallyfy [processes](/products/pro/tracking-and-tasks/processes/) or create [tasks](/products/pro/tracking-and-tasks/tasks/) through the connector's actions. * **Microsoft tools integration** -- Connect Tallyfy with Office 365, SharePoint, Dynamics, and Teams so your whole Microsoft stack works together. * **[Form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) data processing** -- Send data submitted in Tallyfy [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) to other systems automatically. * **Custom notifications** -- Build notification workflows based on Tallyfy events. For 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. For more on how these platforms compare, see these [insights on approvals workflows](https://tallyfy.com/integrations/using-microsoft-flow-for-approvals/). Tallyfy also has built-in approval capabilities. ## Guide to using Power Automate with Tallyfy These articles walk you through connecting Power Automate with your Tallyfy Pro account, from basics to advanced automations. ## Talking to Tallyfy in plain English instead The connector above runs fixed, repeatable steps. You pick an action, map the fields, and it does the same thing every time. That's what you want for a flow that runs a hundred times a week. There's a second path on the Microsoft stack for the times you'd rather just ask. Tallyfy runs an [MCP server](/products/pro/integrations/mcp-server/) (MCP is the standard that lets an AI assistant use an outside tool), and you can wire it into Microsoft Copilot Studio through a Power Platform custom connector. Your agent then launches processes, completes tasks, and answers questions about your workflows from a chat prompt, without you building a flow for each one. The setup steps are on [using the Tallyfy MCP server with Microsoft Copilot Studio](/products/pro/integrations/mcp-server/microsoft-copilot-studio/). You build that custom connector yourself for now. Tallyfy has authored one, but it hasn't been submitted for Microsoft certification, so you won't find it in the Power Platform connector list yet. The two paths sit side by side. Nothing stops you running scheduled flows through the certified connector and letting a Copilot agent handle the one-off questions. ## Key considerations * **Authentication** -- The Tallyfy connector uses OAuth 2.0. You sign in with your Tallyfy account and provide your organization ID during setup. 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 steps. * **Tallyfy connector** -- The connector provides 13 actions (no triggers) covering process launches, task completion, comments, member invitations, and more. See the full [Tallyfy connector for Power Automate](/products/pro/integrations/middleware/power-automate/how-can-i-integrate-tallyfy-with-microsoft-power-automate/) details. * **Tallyfy API and webhooks** -- Need something the connector doesn't cover? Tallyfy's [Open API](/products/pro/integrations/open-api/) and [webhooks](/products/pro/integrations/webhooks/) work with Power Automate's HTTP request action. * **Error handling** -- Set up error handling in your flows to manage failures gracefully. Learn more about [managing and monitoring Power Automate flows](/products/pro/integrations/middleware/power-automate/managing-and-monitoring-power-automate-flows/). * **Rate limits** -- The connector allows 100 API calls per minute per connection. Power Automate also has its own flow execution limits. Power Automate extends Tallyfy Pro by letting you create end-to-end automations that save time and eliminate manual tasks. - **[Workato](https://tallyfy.com/products/pro/integrations/middleware/workato/)**: Tallyfy's Workato connector, built on Workato's Ruby SDK with OAuth 2.0, starts processes, completes tasks, and tracks assignments across enterprise systems. It is in development and not yet in Workato's library, so contact Tallyfy support for early access. ## Workato connector for Tallyfy Tallyfy has built a Workato connector on Workato's Ruby SDK. It connects Tallyfy to enterprise systems through Workato's recipe-based automation, so once it's available you'll be able to launch processes, complete tasks, and track assignments across your tech stack without switching tools. :::note[Not yet available to install] This dedicated connector is built but not yet published to Workato's community library, so you can't add it from inside Workato today. [Contact Tallyfy support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/) for early access. You can still connect Workato to Tallyfy right now using Workato's HTTP connector with [Tallyfy's REST API](/products/pro/integrations/open-api/). The how-to guides below use exactly that approach. ::: ### What the connector does The connector now covers a full set - 82 actions and 10 triggers (5 polling and 5 instant webhook) - detailed in [Workato actions and triggers](/products/pro/integrations/middleware/workato/workato-actions-and-triggers/). The core actions and triggers below cover the most common integration patterns. **Actions:** - **Start process** - launches a new process from a template, with dynamic kick-off form fields pulled from the template's configuration - **Complete task** - marks a task as done, optionally submitting form data along with it - **Update task** - changes a task's name, description, deadline, or assignees (users, guests, or groups) - **Add comment** - posts a comment or problem report on a specific task - **Get process** - retrieves process details, optionally including all its tasks **Triggers (polling-based):** - **New task assigned** - fires when a task gets assigned to the connected user - **Process completed** - fires when a process reaches completed status - **New process started** - fires when a new process is created, with optional filtering by template ### How authentication works The connector uses OAuth 2.0. You'll need three pieces of information to set up the connection: 1. **Client ID** - from your Tallyfy OAuth application 2. **Client Secret** - from the same OAuth application 3. **Organization ID** - found in Tallyfy Settings > Organization The OAuth flow goes through `account.tallyfy.com/oauth/authorize` for authorization and `account.tallyfy.com/oauth/token` for token exchange. Workato handles token refresh automatically, so you won't deal with expired sessions. Every API call includes the `Authorization` bearer token header and an `X-Organization-ID` header. ### Architecture overview ``` Your Systems → Workato Platform → Tallyfy API ↓ ↓ ↓ Salesforce Recipe Engine Start Process SAP Data Transform Complete Task Workday Error Handling Update Task ServiceNow Polling Triggers Add Comment ``` ### Dynamic kick-off form fields When you pick a template in the "Start process" action, the connector fetches that template's kick-off form fields and generates matching input fields in Workato. It maps Tallyfy field types to Workato controls - text, number, date, dropdown, multiselect, boolean, email, and URL fields all get proper input types. This means your recipes can pass data directly into Tallyfy's kick-off forms without manual field mapping. ### Example scenarios **Deal-to-onboarding:** When a deal closes in Salesforce, a Workato recipe starts a Tallyfy customer onboarding process. The recipe maps the customer name, contract value, and account manager from CRM fields into the kick-off form. **Task completion sync:** The "process completed" trigger watches for finished Tallyfy processes, then pushes status updates to your ERP or project management tool. **Assignment routing:** The "new task assigned" trigger picks up fresh assignments and sends notifications through Slack, Teams, or email - whatever your team prefers. ### Key API endpoints used The connector talks to Tallyfy's REST API at `https://go.tallyfy.com/api`. Every call is scoped to your organization, so `{org}` below is your Organization ID: - `POST /organizations/{org}/runs` - start a new process from a template (the template is the `checklist_id` in the request body) - `POST /organizations/{org}/completed-tasks` - complete a task - `PUT /organizations/{org}/runs/{run}/tasks/{task}` - update a task - `POST /organizations/{org}/tasks/{task}/comment` - add a comment to a task - `GET /organizations/{org}/runs/{run}` - get process details - `GET /organizations/{org}/tasks` - list tasks (used by the assignment trigger) - `GET /organizations/{org}/runs` - list processes (used by the process triggers) - `GET /organizations/{org}/checklists` - list templates for dropdown pick lists ### API terminology mapping - "Templates" in the UI = "Blueprints" or "Checklists" in the API - "Processes" in the UI = "Runs" in the API - "Form fields" in the UI = "Captures" in the API - "Steps" in templates = "Tasks" in running processes ### Guest assignment rules The connector enforces Tallyfy's business rule that guests (external users) can't be the sole assignees on a task. If you assign only guest email addresses, the connector automatically adds the current user as a co-assignee. It also validates guest emails against the organization domain - if someone with an internal email is listed as a guest, the connector looks up their user ID instead. ### Error handling The connector returns clear error messages for common failures: - **401** - authentication failed, token refresh needed - **403** - missing organization access - **404** - resource doesn't exist or user lacks access - **422** - validation errors with field-level details - **429** - rate limit exceeded ### Getting early access The dedicated connector isn't in Workato's library yet, so you can't self-install it. To join the early-access group: 1. Contact [Tallyfy support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/) to request the connector and OAuth credentials. 2. Once support provides them, set up the connection in Workato with your Client ID, Client Secret, and Organization ID. 3. Build recipes using the connector's actions and triggers. 4. Test with a sandbox template before going live. Prefer not to wait? Use Workato's HTTP connector with [Tallyfy's REST API](/products/pro/integrations/open-api/) today, following the how-to guides below. - **[Zapier](https://tallyfy.com/products/pro/integrations/middleware/zapier/)**: Tallyfy's Zapier integration lets you launch processes, complete tasks, and sync form data across thousands of apps without coding. Create trigger-action workflows called Zaps to connect Tallyfy with CRMs, HR systems, and more. ## What can you do with Tallyfy's Zapier integration? Zapier connects Tallyfy with thousands of business apps - no coding needed. New to Zapier? Check out our [Zapier explainer](https://tallyfy.com/what-is-zapier/) first. You create automated workflows called "Zaps" that move data between Tallyfy and your other tools automatically. :::note[Considering integration alternatives] Zapier works well for simple connections. For more involved integrations, try [middleware](/products/pro/integrations/middleware/) tools like **n8n** or **Microsoft Power Automate** - they've got more advanced features. If you have developers on your team, Tallyfy's [Open API](/products/pro/integrations/open-api/) gives you full control. You can even use AI to generate serverless function code. ::: ### Key capabilities - **[Launch](/products/pro/launching/) [processes](/products/pro/tracking-and-tasks/processes/) automatically** - Start workflows when something happens in another system - **Complete [tasks](/products/pro/tracking-and-tasks/tasks/)** - Mark tasks done when external conditions are met - **Update [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/)** - Push or pull form data between Tallyfy and other apps - **Create standalone tasks** - Add one-off [tasks](/products/pro/tracking-and-tasks/tasks/) with assignees, deadlines, and tags - **React to completions** - Trigger actions in other apps when Tallyfy tasks or processes finish ### Common scenarios - [Launch](/products/pro/launching/) onboarding when new employees appear in your HR system - Create [tasks](/products/pro/tracking-and-tasks/tasks/) from incoming helpdesk tickets - Send completed [form data](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) to your CRM or ERP - Post Slack notifications when critical [processes](/products/pro/tracking-and-tasks/processes/) start or wrap up ### Getting started 1. Connect your Tallyfy account to Zapier 2. Pick a Tallyfy trigger or action for your Zap 3. Test with sample data 4. Turn it on and let it run :::note[Handling file uploads via Zapier] Passing file content directly from Tallyfy file upload fields to Zapier doesn't always work. A practical workaround: use a text field in Tallyfy to store a **link** to the file (hosted on Google Drive, Dropbox, SharePoint, etc.) and pass that link through Zapier instead. ::: Browse the articles below for setup instructions and specific integration examples. ### Celigo - **[Celigo actions and triggers](https://tallyfy.com/products/pro/integrations/middleware/celigo/celigo-actions-and-triggers/)**: The Celigo connector for Tallyfy grew from a handful of flows to a full set covering users, tasks, processes, templates, form fields, comments, tags, folders, and search, plus four scheduled delta-poll triggers. It authenticates with a Tallyfy API token or OAuth 2.0 through integrator.io. ## What the Celigo connector now covers Celigo maintains an official prebuilt Tallyfy connector inside integrator.io, so you can connect the two today. Separately, Tallyfy has prepared a fuller set of flows that mirror what Tallyfy's other connectors do, across ten categories plus four triggers. That fuller set is a proposed expansion, so the actions below are a target set: what you see inside Celigo today may be smaller. :::note[What's live today vs the proposed expansion] Celigo maintains an official prebuilt Tallyfy connector in integrator.io that you can use today (it supports both a Tallyfy API token and OAuth 2.0). See Celigo's [setup guide](https://docs.celigo.com/hc/en-us/articles/15109930461979-Set-up-a-connection-to-Tallyfy). The fuller flow set described below is a proposed expansion Tallyfy prepared, so treat the counts as a target set, not a separate connector you install. For any action the native connector doesn't cover yet, use Celigo's universal HTTP connector with [Tallyfy's REST API](/products/pro/integrations/open-api/). [Contact Tallyfy support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/) for OAuth credentials or early access. ::: ### Actions by category | Category | What you can do | |---|---| | **Users and guests** | Invite members, read and list users, change roles, enable or disable accounts, create and update guests | | **Groups** | Create, read, update, and delete groups | | **Tasks** | Create standalone tasks, complete tasks (including approvals), update, reopen, and read tasks; list your tasks or a process's tasks | | **Processes** | Launch a process from a template, read, update, archive, reactivate, and list processes | | **Templates** | Read, list, create, clone, update, and delete templates; manage kick-off form fields | | **Form fields** | Add, update, move, delete, and reorder step form fields and kick-off fields | | **Comments and issues** | Add comments, edit or delete them, report an issue on a task, and resolve an issue | | **Tags** | Create, update, and delete tags; tag or untag templates and processes | | **Folders** | Create, update, and delete folders; move templates and processes in and out | | **Search** | Keyword search across tasks, processes, templates, snippets, or everything at once | In total, this prepared set spans 86 flows, up from the original 4. :::note[Not yet included] Automation rules, step-level template edits (adding, cloning, reordering, or reassigning individual steps), and a raw API passthrough flow are a later follow-up. For those, call Tallyfy's [Open API](/products/pro/integrations/open-api/) directly through Celigo's universal HTTP connector. ::: ### Triggers (scheduled delta-poll) Celigo went from zero triggers to four. Tallyfy has no webhook subscription API, so each trigger is a scheduled delta-poll flow: it checks Tallyfy on a schedule, picks up new items, and de-duplicates by record id so nothing repeats. 1. **New process launched** - a process starts, optionally scoped to one template. 2. **Task completed** - a task is marked complete. 3. **Task assigned to you (new task)** - a new task lands in your queue. 4. **Comment or issue added** - a comment or reported issue appears on a watched task or process. Set the poll frequency on the flow's schedule. More frequent polling means fresher data and more API calls. ### Authentication (OAuth 2.0 via integrator.io) Celigo connects to Tallyfy with OAuth 2.0 through integrator.io. Contact Tallyfy support to get a Client ID and Client Secret, then create a connection to Tallyfy in integrator.io using those credentials. OAuth is the right choice for production flows where more than one person authorizes access, and Tallyfy supports bearer tokens with refresh. A personal access token also works for quick tests: go to Settings > Integrations > REST API in Tallyfy and copy your token. It acts on behalf of your own user account. ### Getting started 1. Create or open a flow in integrator.io. 2. Add a Tallyfy connection and authenticate with your OAuth 2.0 credentials (or a personal token for testing). 3. Pick an action, for example Launch process, and map the input fields. 4. To react to Tallyfy events, add one of the four trigger flows and set its schedule. 5. Test with sample data, then turn the flow on. Remember the API terminology: "templates" in the Tallyfy UI are "checklists" in the API, and "processes" are "runs". ## AI-native alternative (Tallyfy MCP) If building flows by hand is more than you need, the Tallyfy MCP server lets an AI assistant call these same actions in plain English. See the [MCP server](/products/pro/integrations/mcp-server/) guide. ### Make - **[Make.com actions and triggers](https://tallyfy.com/products/pro/integrations/middleware/make/make-actions-and-triggers/)**: Make maintains an official, verified Tallyfy connector, live today with core modules for launching processes, completing and creating tasks, comments, and issues. A broader module set covering templates, form fields, tags, folders, and search is a proposed expansion. Connect with your Tallyfy API token and Organization ID. ## What the Make.com connector covers The official Tallyfy connector on Make (formerly Integromat) is built and maintained by Make, and it is live and verified on Make's marketplace today at [make.com/en/integrations/tallyfy](https://www.make.com/en/integrations/tallyfy). Make generated it from Tallyfy's public API, so Make owns and maintains its module set. :::note[Available today, maintained by Make] This connector is live now, so you can add it from inside Make. Its current module set covers the core actions (launching processes, completing and creating tasks, comments, and issues) plus a generic API-call module. The fuller catalog described below (users, templates, form fields, tags, folders, and search across ten categories) is a proposed expansion, not the current live module set. Broadening the official connector would be something Tallyfy coordinates with Make, not a self-serve publish. For anything a module does not cover, use Make's HTTP module with [Tallyfy's REST API](/products/pro/integrations/open-api/). ::: ### Actions by category | Category | What you can do | |---|---| | **Users and guests** | Invite members, read and list users, change roles, enable or disable accounts, create and update guests | | **Groups** | Create, read, update, and delete groups | | **Tasks** | Create standalone tasks, complete tasks (including approvals), update, reopen, and read tasks; list your tasks or a process's tasks | | **Processes** | Launch a process from a template, read, update, archive, reactivate, and list processes | | **Templates** | Read, list, create, clone, update, and delete templates; manage kick-off form fields | | **Form fields** | Add, update, move, delete, and reorder step form fields and kick-off fields | | **Comments and issues** | Add comments, edit or delete them, report an issue on a task, and resolve an issue | | **Tags** | Create, update, and delete tags; tag or untag templates and processes | | **Folders** | Create, update, and delete folders; move templates and processes in and out | | **Search** | Keyword search across tasks, processes, templates, snippets, or everything at once | The proposed expansion above would total 85 modules (81 action modules plus 4 trigger modules), up from the connector's original 7, backed by 9 helper lookups (RPCs) that populate dropdowns like templates and users. This is a wishlist maintained in Tallyfy's connector repo, not the current live module set on Make. :::note[Not yet included] Automation rules, step-level template edits (adding, cloning, reordering, or reassigning individual steps), and a raw API passthrough are a later follow-up. For those, use Make's built-in HTTP module against Tallyfy's [Open API](/products/pro/integrations/open-api/). ::: ### Triggers (polling) Make went from a single trigger to four. Tallyfy has no webhook subscription API, so each trigger polls: it checks Tallyfy on the scenario's schedule, picks up new items, and de-duplicates by record id so nothing repeats. 1. **New process launched** - a process starts, optionally scoped to one template. 2. **Task completed** - a task is marked complete. 3. **Task assigned to you (new task)** - a new task lands in your queue. 4. **Comment or issue added** - a comment or reported issue appears on a watched task or process. Set the interval on the scenario schedule. More frequent polling means fresher data and more API calls. ### Authentication Make.com connects to Tallyfy with a Tallyfy API token plus your Organization ID. Both are in your Tallyfy Settings. That keeps setup simple: paste the token once and the connection is ready. Because the token acts on behalf of the user who created it, use a token from an account with the right permissions for what your scenarios do. ### Getting started 1. Create a Make account and start a new scenario. 2. Add the official Tallyfy connector and create a connection with your Tallyfy API token and Organization ID. 3. Pick an action module, for example Start process, and map the input fields. 4. To react to Tallyfy events, add one of the four trigger modules and set the scenario schedule. 5. Test with sample data, then activate the scenario. ## AI-native alternative (Tallyfy MCP) If building scenarios by hand is more than you need, the Tallyfy MCP server lets an AI assistant call these same actions in plain English. See the [MCP server](/products/pro/integrations/mcp-server/) guide. ### N8n - **[Common n8n workflow examples](https://tallyfy.com/products/pro/integrations/middleware/n8n/common-n8n-workflow-examples/)**: Ready-to-use n8n workflow patterns for automating Tallyfy processes. Covers CRM-triggered onboarding, multi-system form routing, AI-powered task assignment, and scheduled data collection with error handling. ## Practical n8n workflows for Tallyfy automation n8n lets you connect Tallyfy to the other tools your business already uses, without building a full app. You set up a workflow once, and it runs on its own. Here are six jobs teams most often hand to n8n: - **Start a process when a deal closes.** When your CRM marks a deal as won, n8n launches a customer onboarding process in Tallyfy for you. - **Keep every system in sync.** When someone finishes a Tallyfy form, n8n copies the answers into your CRM, a spreadsheet, and a confirmation email at once. No retyping. - **Run scheduled reviews.** On a set day each week, n8n pulls numbers from your other tools and launches a review process with that data already filled in. - **Generate reports on their own.** When a process finishes, n8n collects the results and builds a PDF you can file or send. - **Route work with AI.** n8n can read a form answer, judge how urgent it is, and assign the task to the right person. - **Add a human approval step.** n8n can pause and wait for someone to approve, reject, or revise before it carries on. Handy for checking AI-written content before it's sent out. The full build for each one is below, with the exact nodes and settings you can copy. ## For developers *(Skip this unless you're setting up the technical side.)* > All Tallyfy API URLs require your organization ID. Replace `{org_id}` with your actual organization ID in every endpoint below. ### 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 deal status change notifications - 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/organizations/{org_id}/runs` - Body: ```json { "checklist_id": "f7e6d5c4b3a2918070615243342516f0", "name": "Onboarding - {{$json.customer_name}}", "prerun": { "a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6": "{{$json.customer_name}}", "9f2b7c1e4a6d8035b1c7e9d2f4a6b801": "{{$json.email}}", "3c9d1e7fa4b820516d8e2f7a9c0b4d15": "{{$json.deal_type}}", "6e4a2c80f19b3d75e0a8c246b93f157d": "{{$json.assigned_to}}" } } ``` Pre-filled kick-off values go in a `prerun` object, and every key is a kick-off field's timeline ID - a 32-character hex string, not the field's label or alias. Get those IDs from `GET /organizations/{org_id}/checklists/{checklist_id}` and read the `id` on each entry of the `prerun` array. A key that matches no field is dropped silently, so the process still launches with that field empty. Each `prerun` value's shape depends on the field type. The per-type list lives on [Launch process](/products/pro/integrations/open-api/code-samples/processes/launch-process/). 4. **Slack node** (optional) - Notify sales team about the process launch ### Example 2: Form submission to multi-system update Update multiple systems whenever someone submits a Tallyfy [form](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/). You don't need to copy data manually. **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 5. **Google Sheets node** - Log submission - Append row with form data and timestamp 6. **Email node** - Send confirmation - To: Form submitter with 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 branches** - CRM, Google Sheets, and email updates run simultaneously - **Conditional path** - The IF node skips tasks without forms, so it doesn't process them ### Example 3: Scheduled process launcher with data collection Launch weekly review processes that automatically gather data from your tools. **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 for 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/organizations/{org_id}/runs` - Include collected data in kickoff fields ### Example 4: Document generation from completed processes Generate PDF reports automatically when Tallyfy processes finish. **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/organizations/{org_id}/runs/{{$json.run_id}}` 3. **HTTP Request node** - Get all task data - Method: GET - URL: `https://go.tallyfy.com/api/organizations/{org_id}/runs/{{$json.run_id}}/tasks` 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 formatted report layout 6. **Convert to PDF node** (or external service) 7. **Upload to cloud storage** - Google Drive, Dropbox, or S3 ### Example 5: Intelligent task routing with AI Use AI to analyze Tallyfy form responses and route tasks to the right people 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/organizations/{org_id}/tasks/{{$json.task_id}}` - Assign to appropriate Tallyfy [member](/products/pro/documenting/members/) based on routing 5. **Notification nodes** - Alert assigned team member via their 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 n8n's "Send and wait for response" nodes pause workflows for human input. That's how you turn hours of manual review into quick approval checks. **Pattern:** 1. **AI generates content** (proposal, report, blog post) 2. **Workflow pauses** with Slack/Email notification for review 3. **Human reviews** and responds (approve/reject/modify) 4. **Workflow continues** based on the response **Workflow components:** 1. **Trigger node** - Webhook, schedule, or manual start 2. **AI Agent node** - Generate content that needs review - Configure with your preferred LLM (Claude, GPT-4, etc.) - Use clear system prompts for consistent output 3. **Slack node** (Human in the Loop category) - Action: **Send message and wait for reply** - Include "Approve" / "Reject" / "Revise" instructions - Workflow pauses until a response arrives 4. **Switch node** - Route based on response - "Approved" - continue to next action - "Rejected" - log, notify, and end - "Revise" - loop back to AI with feedback 5. **Action nodes** - Execute based on approval - Send proposal, publish content, or update CRM **Use cases:** - **Review proposals before delivery** - AI drafts, human verifies pricing and scope - **Approve AI content before publishing** - catch hallucinations or tone issues - **Validate data enrichment** - confirm AI matched the right company You can chain multiple "Send and wait" nodes with different reviewers for multi-level approvals. ### Switch nodes for intelligent routing Use AI classification with a Switch node instead of complex IF/ELSE chains. **Pattern:** ``` Webhook → AI Agent (classify request) → Switch Node → Multiple specialized paths ``` **Configuration:** 1. **AI Agent node** - Classify the input - System prompt: "Classify this request as exactly one of: URGENT, NORMAL, or LOW_PRIORITY" - Output a single keyword 2. **Switch node** - Route by classification - Mode: **Rules** - Rule: Value equals "URGENT" - Output 0 (urgent path) - Rule: Value equals "NORMAL" - Output 1 (normal path) - Fallback: Output 2 (low priority path) 3. **Specialized handling per path** - URGENT: Immediate Slack alert + assign to senior staff - NORMAL: Standard queue + email notification - LOW_PRIORITY: Batch processing + weekly digest Works well for support ticket triage, lead scoring, content categorization, and compliance checks. ### Best practices for n8n + Tallyfy workflows 1. **Error handling** - workflows will fail eventually, so plan for it: ``` On Error: Continue (Error Output) → Log error details → Send alert notification → Store failed data for retry ``` 2. **Rate limiting** - add **Wait** nodes between bulk operations. A 1-second delay between API calls prevents throttling. 3. **Data validation** - use **IF** nodes to confirm required fields exist and formats match what Tallyfy expects before sending data. 4. **Workflow organization** - use **Sticky Note** nodes to document the workflow's purpose, required credentials, and expected data formats. 5. **Testing** - start with **Manual Trigger** and **Set** nodes for test data. Use **Stop and Error** nodes for debugging. 6. **Retry settings** - set retry count to 2+ on AI and HTTP nodes with 5000ms between attempts. This handles temporary rate limits automatically. 7. **Version history** - n8n keeps recent workflow versions, but you'll want to use **Export as JSON** for permanent backups before major changes. ### 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** - use the **Split In Batches** node to handle multiple items while respecting rate limits. **Retry logic** with **Wait** and **IF** nodes: 1. Set a retry counter 2. On error, increment the counter 3. Wait exponentially longer between retries (2s, 4s, 8s) 4. Stop after max retries **Data enrichment** - chain multiple API calls to gather complete data before launching Tallyfy processes. Pull customer history, support tickets, or sales data into one picture before kicking off a workflow. - **[Connecting n8n](https://tallyfy.com/products/pro/integrations/middleware/n8n/connecting-n8n-to-tallyfy/)**: n8n connects to Tallyfy in about five minutes using either a community-built Tallyfy node or HTTP Request nodes. It supports 60+ operations across blueprints, processes, tasks, comments, users, and groups. ## Connect n8n to Tallyfy Connecting n8n to Tallyfy takes about 5 minutes. You've got two options: use the community-built Tallyfy node for quick setup, or use HTTP Request nodes for full flexibility. Both work with Tallyfy's [Open API](/products/pro/integrations/open-api/) and handle authentication automatically. ### 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 handles most use cases. HTTP Request nodes give you complete flexibility for custom integrations. - Both methods converge at the authentication test - if it fails, check your API token and permissions first. - After connecting, you get access to 60+ operations across multiple resources. ### Prerequisites - An active Tallyfy account with API access - n8n installed (self-hosted, cloud, or local) - Your Tallyfy API token and Organization ID - For HTTP Request method: basic REST API knowledge ### Step 1: Get your Tallyfy API credentials :::warning[API token security] Treat your API token like a password. Don't share it publicly or commit it to version control. In n8n, always 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` ### Step 4: Available operations | Resource | Operations | Use cases | |----------|-----------|-----------| | **Blueprint** | Get, Get Many, Create, Update, Delete | Template management | | **Process** | Launch, Get, Get Many, Update, Archive, Get Tasks | Process lifecycle | | **Task** | Create One-Off, Complete, Get, Get Many, Update Properties, Delete, Clone | Task management | | **Form Field** | Get Fields, Update Value | Data collection | | **Comment** | Create, Create Bot, Report Problem, Resolve Issue, Update, Delete | Communication | | **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 participants | | **Group** | Create, Get, Get Many, Update, Delete | Team organization | | **Search** | Global, Tasks, Processes, Blueprints | Finding resources | | **ID Finder** | Find Process/Task/Blueprint/Form Field/User/Group IDs | Resource lookup | **Key features:** - Built-in pagination with a "Return All" toggle - Automatic error handling and retry logic - Field validation and type checking - Dynamic field values through n8n expressions ### Step 5: Launch a process **Tips:** - Field names must match your blueprint's kickoff form fields exactly - Use n8n expressions to map data from previous nodes - 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] n8n gives you two webhook URLs: a **Test URL** and a **Production URL**. The production URL only works when the workflow is set to "Active." A common trap: 1. You 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 swap to the Production URL in Tallyfy when going live.** The Test URL stops working once you activate. ::: ### Webhook event flow This diagram shows how events flow from Tallyfy to n8n. [Diagram removed for brevity] **What to notice:** - Events queue immediately when triggered, so nothing gets lost during high load - Retries use exponential backoff to handle temporary network issues without overwhelming your n8n instance ### Debugging with the executions panel n8n records every workflow execution with full input/output data at each node. This makes debugging straightforward. ![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** at the top of the workflow editor - Each entry shows status (success/error), timing, and trigger source - Click any execution to inspect the data flowing through each node - Filter by date or status to find specific runs **Data pinning - skip expensive operations during testing:** When building workflows with AI agents or external API calls, re-running every node on each test is slow and costly. Data Pinning freezes a node's output so it's reused in subsequent test runs. 1. Run your workflow to get real data through the nodes 2. Click on any node with output data 3. Click the **Pin** icon to lock that output 4. On future tests, n8n skips that node and uses the pinned data This is especially useful for AI agent workflows, slow API calls, or rate-limited services. **Copy execution to editor:** If a production execution fails, you can reload it into the editor for debugging: 1. Find the 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 4. Test individual nodes or modify and re-run ### Troubleshooting guide | Issue | Cause | Fix | |-------|-------|-----| | **401 Unauthorized** | Invalid or expired token | Regenerate your API token in Tallyfy | | **403 Forbidden** | Insufficient permissions | Check that your user role allows API access | | **404 Not Found** | Wrong endpoint or resource ID | Verify your Organization ID and resource IDs | | **422 Unprocessable Entity** | Invalid data format | Check required fields and data types | | **429 Rate limiting** | Too many requests | Add 1-2 second delays between calls | | **Connection timeout** | Network or server issues | Enable retry logic with exponential backoff | | **Webhook not firing** | URL or events misconfigured | Double-check the webhook URL and selected events | | **Webhook works in test only** | Using Test URL in production | Swap to the Production URL after activating the workflow | | **AI node timeouts** | Re-running expensive operations | Use Data Pinning to cache outputs while building | **Advanced debugging:** - Enable **Retry on Failure** in node settings - Use **Split in Batches** for 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 **Performance:** - 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 **Data handling:** - Use pagination for large datasets (Tallyfy defaults to 10 items per page) - Validate required fields before sending API requests - Handle edge cases like missing users or archived processes ### Advanced integration patterns Once connected, you can build automations like: - **AI-enhanced workflows** - Analyze form responses with AI, generate summaries, or auto-categorize incoming requests - **Multi-system orchestration** - Launch Tallyfy processes from CRM deals, sync tasks to project tools, or build cross-platform approvals - **Real-time dashboards** - Stream process metrics to BI tools or send alerts when SLAs are at risk - **[n8n actions and triggers](https://tallyfy.com/products/pro/integrations/middleware/n8n/n8n-actions-and-triggers/)**: The n8n community node for Tallyfy grew from 55 operations to 96 across users, tasks, processes, templates, form fields, comments, tags, folders, groups, and search, plus a new Tallyfy Trigger node with polling and instant (webhook) modes, all authenticated with a personal access token. ## What the n8n node now covers The Tallyfy community node for n8n (`n8n-nodes-tallyfy`) already had the broadest coverage of any Tallyfy connector, and it grew again. It went from 55 operations to 96, covering the same ten action categories as Tallyfy's other connectors, and it gained something it never had before: a Tallyfy Trigger node that runs in two modes, polling and instant webhooks. :::note[Available now on npm] The expanded operation set (96 operations) and the new Tallyfy Trigger node are published on npm in version 1.1.1, so `npm install n8n-nodes-tallyfy` gives you the full set today. Version 1.1.1 also includes the fix for encoding choice-field values (dropdown, multiselect, and radio) when you pass them into a kickoff form on launch. ::: ### Actions by category | Category | What you can do | |---|---| | **Users and guests** | Invite members, read and list users, change roles, enable or disable accounts, read your organization's details, create, update, and delete guests, and convert members to guests (or back) | | **Groups** | Create, read, update, and delete groups | | **Tasks** | Create standalone tasks, complete tasks (including approvals), update, reopen, clone, and delete tasks; list your tasks, another member's, a guest's, or a process's tasks | | **Processes** | Launch a process from a template, read, update, archive, reactivate, and list processes; submit or reopen a kickoff form | | **Templates** | Read, list, create, clone, update, and delete templates; list a template's steps and read its kickoff form fields | | **Form fields** | Set form field values on tasks; add, update, move, and delete step form fields; manage dropdown options; add, update, delete, and reorder kickoff fields | | **Comments and issues** | Add comments (including bot comments that skip notifications), edit or delete them, list a task's comments, report an issue on a task, and resolve an issue | | **Tags** | List, create, update, and delete tags; tag or untag templates and processes | | **Folders** | List, create, update, and delete folders; move templates and processes in and out | | **Search** | Keyword search across tasks, processes, templates, snippets, or everything at once; six ID Finder lookups turn a name into the ID you need | In total the node now ships 96 operations across 12 resources, up from 55. In the node's Resource dropdown you'll see Blueprint, Process, Task, Form Field, Comment, User, Guest, Group, Tag, Folder, Search, and ID Finder. :::note[Not yet included] Automation rules, step-level template edits (adding, cloning, reordering, or reassigning individual steps), and a raw API passthrough operation are a later follow-up. For those, use n8n's built-in HTTP Request node with Tallyfy's [Open API](/products/pro/integrations/open-api/). ::: ### Triggers (polling) The Tallyfy Trigger node runs in two modes, chosen with the **Mode** dropdown when you add it: **Polling** (works everywhere today) and **Instant (Webhook)** (real time, covered below). In Polling mode it checks Tallyfy on the schedule you set, picks up new items, and de-duplicates by record id so nothing repeats. The four polling triggers: 1. **New process launched** - a process starts, optionally scoped to one template. 2. **Task completed** - a task is marked complete. 3. **Task assigned to you (new task)** - a new task lands in your queue. 4. **Comment or issue added** - a comment or reported issue appears on a watched process (a single process, or every process from one template). Set the poll frequency on the trigger node's schedule. More frequent polling means fresher data and more API calls. The first poll after you activate a workflow takes a snapshot, so the trigger only fires for items that show up after that. It won't replay your history. ### Triggers (instant, webhook-based) Switch the node's **Mode** to **Instant (Webhook)** and Tallyfy pushes events to n8n the moment they happen, so the workflow runs in real time instead of on the next poll. One node covers seven events, and you tick the ones you want in the **Events** list: 1. **Process launched** (`process.launched`) - a process is launched from a template. 2. **Process completed** (`process.completed`) - a whole process reaches completed status. 3. **Task completed** (`task.completed`) - a task is marked complete. 4. **Task assigned** (`task.assigned`) - a task is assigned to someone. 5. **Comment added** (`task.comment_added`) - a comment is posted on a task. 6. **Issue raised** (`task.issue_raised`) - an issue is reported on a task. 7. **Issue resolved** (`task.issue_resolved`) - a reported issue is resolved. When you activate the workflow, the node registers one organization-wide webhook with Tallyfy and removes it when you deactivate. Tallyfy then posts every selected event to that single webhook. :::note[Instant mode needs an org admin, and the backend is rolling out] Registering an organization webhook requires an organization admin token. A non-admin token gets a permission error on activation, so either connect an admin account or switch the node back to Polling mode. Tallyfy's organization-webhook backend is also still rolling out to production, so until your organization has it enabled an instant trigger may not fire. Use Polling mode meanwhile, then switch to Instant once your organization has it. ::: ### Authentication (personal access token) n8n connects to Tallyfy with a **Tallyfy API** credential that holds two required values: your personal access token and your Organization ID. Get the token from **Settings** > **Integrations** > **REST API** in Tallyfy; your Organization ID is in your Tallyfy URL. A third field, the API base URL, comes pre-filled, so you can leave it alone. The token acts on behalf of the user who created it. Use a token from an account with the right permissions for what your workflows do. The credential also has a built-in test that checks the token against your own Tallyfy profile, so you'll know it works before you build anything. ### Getting started 1. Install the Tallyfy community node - on a self-hosted instance, run `npm install n8n-nodes-tallyfy`. 2. In n8n, create a **Tallyfy API** credential with your access token and Organization ID, then run the credential test. 3. Add a **Tallyfy** node to a workflow, pick a resource and operation, for example Process > Launch, and map the input fields. 4. To react to Tallyfy events, add a **Tallyfy Trigger** node, choose one of the four triggers, and set its poll schedule. 5. Test with sample data, then activate the workflow. Remember the naming: "templates" in the Tallyfy UI show up as Blueprints in the node (the API also calls them "checklists"), and "processes" are "runs". The full setup walkthrough, including the HTTP Request alternative, is in [Connecting n8n](/products/pro/integrations/middleware/n8n/connecting-n8n-to-tallyfy/). ## AI-native alternative (Tallyfy MCP) If building workflows by hand is more than you need, the Tallyfy MCP server lets an AI assistant call these same actions in plain English. See the [MCP server](/products/pro/integrations/mcp-server/) guide. - **[n8n vs other middleware platforms](https://tallyfy.com/products/pro/integrations/middleware/n8n/n8n-vs-other-middleware-platforms/)**: n8n works best for high-volume Tallyfy integrations because it charges per workflow execution, not per operation. It also offers self-hosting for data privacy, while Zapier suits quick setups and Power Automate fits Microsoft-heavy organizations. ## Choosing the right middleware for Tallyfy Your [middleware](/products/pro/integrations/middleware/) choice directly affects automation power, monthly costs, and control over your Tallyfy integrations. Here's how n8n stacks up against Zapier, Make, and Power Automate. ### 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** | ✅ Community node (60+ ops) | ✅ 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 **Cost efficiency at scale**: n8n charges per workflow execution, not per operation. Check 100 Tallyfy [tasks](/products/pro/tracking-and-tasks/tasks/)? That's one execution. Other platforms count that as 100 operations. **Data privacy**: Self-hosting n8n means your Tallyfy data stays on your servers. For organizations with strict [compliance](/products/pro/compliance/) requirements, that's a dealbreaker in n8n's favor. **Developer-friendly features**: - Custom JavaScript or Python code within workflows - Step-by-step execution debugger - Version control for workflow definitions - API-first design that pairs well with Tallyfy **No vendor lock-in**: Export workflows as JSON, switch instances, modify programmatically. ### When to choose n8n Pick n8n when you have: 1. **High-volume integrations** - hundreds of Tallyfy tasks or dozens of process launches daily 2. **Complex data transformations** - reshaping 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** - per-operation pricing adds up fast at scale 6. **HIPAA compliance** - self-hosted deployment for PHI data handling ### When other platforms fit better **Choose Zapier when:** - You need something running in 5 minutes - You're connecting just a few simple workflows - You prefer a native Tallyfy connector over community node setup **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 **Choose Power Automate when:** - Your organization already runs on Microsoft 365 - You need desktop automation alongside web integrations - You have Power Platform licenses already ### Cost breakdown **Scenario**: Daily sync of 50 Tallyfy processes, each with 10 tasks to check and update across CRM and project management tools. - **n8n Self-hosted**: Infrastructure costs only - no subscription fees - **n8n Cloud**: Execution-based pricing - **Zapier**: Each operation counts toward your task quota - **Make**: Operation-based pricing - **Power Automate**: Flow run or per-user licensing Check each platform's current pricing page - models and tiers change frequently. **Cost-saving tip**: n8n's test executions don't count toward your quota. You can debug complex Tallyfy integrations at scale before going live without burning through paid operations. ### Integration complexity comparison **Simple integration** (launch process from form): - **Zapier**: ~5 minutes with native connector - **n8n**: ~5 minutes with community node, ~10 minutes with HTTP Request - **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 comparison details **Debugging and monitoring**: - n8n: Full execution history with complete data visibility - Zapier: Basic task history - Make: Good execution logs with data flow visualization - Power Automate: Detailed run history with analytics **Webhook handling**: - n8n: Unlimited webhooks on any plan - Zapier: Webhooks on paid plans only - Make: Webhooks on all plans - Power Automate: Full webhook support ### Migrating to n8n Switching from another platform? Here's what to expect: 1. **Workflow recreation** - no direct import, but n8n's flexibility often simplifies complex workarounds 2. **Credential setup** - one-time Tallyfy API configuration 3. **Testing period** - run both platforms side-by-side for a week or two 4. **Training** - your team needs basic API understanding ### Hybrid approach Some organizations mix platforms: Zapier for simple non-technical workflows, n8n for complex or sensitive integrations, Power Automate for Microsoft-specific connections. That can work well if you manage the overlap. ### Making your decision 1. **Volume**: High task volume? n8n's execution-based pricing wins 2. **Complexity**: Need branching logic and custom code? That's n8n 3. **Security**: Must self-host? Only n8n offers that 4. **Team skills**: Non-technical team? Zapier's easier to learn 5. **Platform fit**: Deep in Microsoft 365? Power Automate fits naturally 6. **Budget**: Compare total cost of ownership at your expected volume n8n's community node and HTTP Request node both connect to Tallyfy's [Open API](/products/pro/integrations/open-api/), so you're never stuck waiting for connector updates. ### Power automate - **[Automating Microsoft Entra ID with Power Automate](https://tallyfy.com/products/pro/integrations/middleware/power-automate/automating-azure-ad-with-power-automate/)**: Use Power Automate to handle Microsoft Entra ID identity tasks like syncing Tallyfy members to security groups and generating access review reports. Built-in connectors cover common operations, while the Microsoft Graph API handles advanced scenarios like custom role assignments. Microsoft Entra ID (formerly Azure Active Directory) is Microsoft's cloud-based identity service. Power Automate pairs well with it for automating repetitive identity admin tasks - especially when you're managing Tallyfy [members](/products/pro/documenting/members/) and their access through [SSO](/products/pro/integrations/authentication/). ## Why automate Entra ID for Tallyfy Power Automate can handle the busywork: onboarding users who need Tallyfy access, removing people when they leave, managing group-based roles, and generating compliance reports. * **Sync [members](/products/pro/documenting/members/) automatically:** When your Tallyfy member list ties to Entra ID groups, Power Automate adds and removes users for you. * **Control access through [SSO](/products/pro/integrations/authentication/):** Link Tallyfy SSO to Entra ID security groups, then let Power Automate manage group membership. * **Generate compliance reports:** Pull Entra ID group membership data for quarterly access reviews in seconds. ## Key Entra ID actions for Tallyfy integration Here's what Power Automate offers for Entra ID and Tallyfy: * **Entra ID Connector:** The main tool for user and group operations affecting Tallyfy access. See [understanding Power Automate basics](/products/pro/integrations/middleware/power-automate/understanding-power-automate-basics/) for connector fundamentals. * `Get user profile (V2)` and `Get manager (V2)`: Pull user details for Tallyfy [task](/products/pro/tracking-and-tasks/tasks/) assignments. * `Create user`, `Update user`, `Delete user`: Automate the full user lifecycle - joining, changing roles, or leaving. * `Add user to group`, `Remove user from group`: Control which Entra ID groups grant Tallyfy access. * `List group members`, `List users`: Build "who has access to what" reports. * **Office 365 Groups Connector:** Useful if you organize teams needing Tallyfy access through Microsoft 365 Groups. * **HTTP with Microsoft Graph API (Advanced):** For anything the standard connectors can't handle - like pulling custom user attributes for Tallyfy role assignments. See [connecting Power Automate to external data](/products/pro/integrations/middleware/power-automate/connecting-power-automate-to-external-data/). ## Example - add a new Tallyfy member to an Entra ID group **Scenario:** Sales [members](/products/pro/documenting/members/) joining Tallyfy should be automatically added to a "Tallyfy Users" Entra ID security group. *This assumes you have a trigger for when someone joins Tallyfy. Tallyfy supports [webhooks](/products/pro/integrations/webhooks/) for member events (like user invited and user activated), or you could use an HR system trigger. For this demo, we'll use a [manual trigger](/products/pro/integrations/middleware/power-automate/triggering-flows-manually-button-flows/).* ## Example - monthly Tallyfy access review report **Scenario:** You need a monthly CSV report of everyone in your "Tallyfy General Access" Entra ID group, emailed automatically. ## HTTP connector for advanced Entra ID tasks When the standard connector falls short - say you need custom user properties for Tallyfy role assignments - use the HTTP action with Microsoft Graph API. Full details in [connecting Power Automate to external data](/products/pro/integrations/middleware/power-automate/connecting-power-automate-to-external-data/). You'll need to set up: 1. **App Registration in Entra ID** with the right API permissions. 2. **Secure credentials** in your HTTP action. 3. **HTTP Action Configuration** - method, URI, headers, and body for Graph API calls. 4. **Parse JSON Action** to make the response usable in your flow. This approach requires familiarity with Entra ID app registrations and Graph API, but it opens up far more flexibility. ## Tips for Tallyfy and Entra ID automation * **Least privilege:** Give API permissions and service accounts only what they need. * **Use Object IDs, not display names:** Display names change. Object IDs don't. Always reference groups by Object ID in your flows. * **Test with real permissions:** If regular users run these flows, test under their account - not your admin credentials. * **Automate the full lifecycle:** Hook into Entra ID lifecycle events to provision and deprovision Tallyfy [members](/products/pro/documenting/members/) automatically. This pairs well with [SSO](/products/pro/integrations/authentication/). - **[Advanced conditions and expressions in Power Automate](https://tallyfy.com/products/pro/integrations/middleware/power-automate/advanced-conditions-and-expressions/)**: Power Automate expressions, grouped conditions, and Switch controls handle Tallyfy workflow logic beyond basic if-then rules. Use calculations on form field data and multi-outcome branching based on task values and process states. Basic if-then logic works for simple Tallyfy [processes](/products/pro/tracking-and-tasks/processes/) in Power Automate. But real workflows get messy fast - they need multiple conditions, calculations, and edge case handling. Three techniques help you make smarter decisions with Tallyfy data: expressions, grouped conditions, and the Switch control. ## Conditional logic refresher The **Condition** control - covered in [using conditional logic in Power Automate](/products/pro/integrations/middleware/power-automate/using-conditional-logic-in-power-automate/) - checks whether something's true or false and routes your flow accordingly. The techniques below extend those basics to handle more complex Tallyfy data scenarios. ## Working with expressions in conditions Expressions are formulas that manipulate Tallyfy data, run calculations, and pull specific properties from dynamic content. Pair them with conditions and you can handle the real-world edge cases in your 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 appears. Switch to the **Expression** tab. 3. Type or select functions to build your expression. Common expression functions for Tallyfy data: * **String functions:** * `concat('string1', 'string2')` - joins strings * `substring('text', startIndex, length)` - extracts part of a string * `toLower('TEXT')` / `toUpper('text')` - converts case (handy for case-insensitive comparisons of Tallyfy [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) values) * `contains('text', 'searchText')` - checks if text includes a substring * `startsWith('text', 'searchText')` / `endsWith('text', 'searchText')` * **Date/time functions:** * `utcNow()` - current UTC date and time * `addDays(timestamp, days, 'format')` - adds days to a date (e.g., calculating a new deadline from a Tallyfy [task's](/products/pro/tracking-and-tasks/tasks/) start date) * `formatDateTime(timestamp, 'formatString')` - formats a date/time (e.g., `'yyyy-MM-dd'`) * **Conversion functions:** * `int('stringValue')` - string to integer (useful when a Tallyfy [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) stores a number as text) * `string(value)` - value to string * `float('stringValue')` - string to floating-point number * **Logical functions:** * `if(condition, valueIfTrue, valueIfFalse)` * `and(condition1, condition2)` / `or(condition1, condition2)` / `not(condition)` * `empty(value)` - checks if a string, array, or object is empty * `equals(value1, value2)` - checks for equality **Tallyfy example - checking if a task is overdue:** Suppose a Tallyfy [task](/products/pro/tracking-and-tasks/tasks/) stores its due date in a text [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) called `TaskDueDateText`: * **Value 1 (Expression):** `formatDateTime(outputs('Get_task_details')?['body/forms/TaskDueDateText/value'], 'yyyy-MM-dd')` * This assumes a consistent date format. If formats vary, you'll need additional parsing. * **Operator:** `is less than` * **Value 2 (Expression):** `formatDateTime(utcNow(), 'yyyy-MM-dd')` ## Grouping conditions (AND/OR logic) The [basic conditions article](/products/pro/integrations/middleware/power-automate/using-conditional-logic-in-power-automate/) covers adding multiple rows to a Condition control. Grouping takes this further by letting you nest logic. 1. **Add multiple rows:** Click **+ Add** > **Add row** within your condition. 2. **Select rows:** Check the boxes next to the condition rows you want to group. 3. **Make group:** Click the ellipsis (...) on a selected row and choose **Make group**. Each group gets its own AND/OR operator, and you set a separate AND/OR for how that group relates to other conditions at the same level. This works like parentheses in logic - great for "if this AND that, OR if something else entirely" scenarios with Tallyfy [processes](/products/pro/tracking-and-tasks/processes/). **Tallyfy example:** Escalate a [process](/products/pro/tracking-and-tasks/processes/) IF: (Process 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 When you're checking one Tallyfy [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) value against many possible matches, nested conditions get unwieldy fast. The **Switch** control is cleaner, easier to read, and simpler to maintain. * **Structure:** 1. Add a **Switch** control. 2. **On:** Set the value to evaluate (e.g., a Tallyfy [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) via dynamic content). 3. **Case:** Add a **Case** branch for each possible value. Enter the matching value in the **Equals** field. 4. Place the actions for that case inside its branch. 5. **Default:** Runs if none of the Case values match. ### 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:** A [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 values "Information," "Access," and "Hardware." * SWITCH ON: `outputs('Get_task_details')?['body/forms/RequestType/value']` * CASE `Information`: Send an email with knowledge base links. * CASE `Access`: Create an approval request, possibly using [Power Automate approvals with Teams](/products/pro/integrations/middleware/power-automate/integrating-power-automate-approvals-with-microsoft-teams/). * CASE `Hardware`: Launch a Tallyfy "Hardware Procurement" [template](/products/pro/documenting/templates/). * DEFAULT: Notify IT support about an unclassified request. ## Advanced conditional patterns * **Checking for null or empty values:** Always check if optional Tallyfy [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) are empty before using them - otherwise your flow crashes when the value doesn't exist. Use `empty()`: * Condition: `empty(outputs('Get_task_details')?['body/forms/OptionalComment/value'])` * Operator: `is equal to` * Value: `true` (expression) * **Error handling:** Use "Configure run after" settings on actions within conditional branches to handle failures. If a step fails, you can retry, skip, or take an alternative path. 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:** 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 and test complex expressions before plugging them into conditions. Power Automate doesn't support inline comments, so document complex logic externally. * **Modularity:** If you're drowning in nested conditions, break the flow into smaller child flows. It adds management overhead but keeps things maintainable. * **Data type awareness:** Tallyfy [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) often store values as text. Convert before comparing - use `int()`, `float()`, or `formatDateTime()`. Comparing "10" to 2 as strings produces wrong results. * **Testing:** Test every path through your conditions and switches with different Tallyfy data - valid inputs, edge cases, and empty values. Catch issues before production. - **[Building approval workflows with Power Automate](https://tallyfy.com/products/pro/integrations/middleware/power-automate/building-approval-workflows-with-power-automate/)**: Power Automate's formal approval actions can wrap around Tallyfy processes to handle conditional sign-offs like budget thresholds and route decisions through managers or external reviewers before updating results back into the originating Tallyfy task automatically. Many business [processes](/products/pro/tracking-and-tasks/processes/) require formal sign-off. Tallyfy handles [task](/products/pro/tracking-and-tasks/tasks/) assignments and completions well, but sometimes you need Power Automate's approvals feature for audit trails, complex routing, or external reviewers who aren't in Tallyfy regularly. ## Why use Power Automate approvals with Tallyfy Power Automate approvals request and track formal sign-off through automated workflows. Connect a flow to Tallyfy's API, trigger an approval action, and the request goes to your designated approvers. The real value: you can wrap formal sign-off steps around your Tallyfy [processes](/products/pro/tracking-and-tasks/processes/). For example, your Tallyfy process produces a document needing client approval. Power Automate handles that external approval loop, then updates your Tallyfy process based on the client's decision. :::note[Dataverse backend] Power Automate approvals use Microsoft Dataverse to store approval history. You don't need to interact directly with Dataverse for standard Tallyfy-related approval scenarios. ::: :::caution[Tallyfy connector limitations] The Tallyfy Power Automate connector is action-only - it has no built-in triggers. To start flows based on Tallyfy events, use Power Automate's HTTP connector with Tallyfy's API, or use a recurrence trigger that polls for changes. The walkthrough below uses conceptual action names to illustrate the pattern. ::: ## Types of approval actions in Power Automate When building approval flows for Tallyfy items, you'll work with the "Approvals" [connector](/products/pro/integrations/middleware/power-automate/understanding-power-automate-basics/): * **Start and wait for an approval:** Kicks off an approval for a Tallyfy-related item and waits for a response. * *Common types:* * **Approve/Reject - First to respond:** With multiple approvers, the first response determines the outcome. * **Approve/Reject - Everyone must approve:** All approvers must respond. One rejection means the item is rejected. * **Custom Responses - Wait for one/all responses:** Define custom action buttons beyond Approve/Reject. * **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 Here is a practical example: completing a Tallyfy [task](/products/pro/tracking-and-tasks/tasks/) triggers manager approval when a financial threshold in a [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) is crossed. **The scenario:** A team member completes 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." Amounts over $5,000 need manager approval through Power Automate, and the result updates back in Tallyfy. ### 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:** Budget approval workflow integrating Tallyfy with Power Automate. A completed task triggers conditional approval based on a $5,000 threshold, branching to bypass approval for smaller amounts or route through manager approval for larger ones. **What to notice:** - Amounts below $5,000 bypass approval entirely, while higher amounts trigger the full approval flow - Manager approval happens in Power Automate, but the result updates back to the Tallyfy task - The rejection path includes an optional email notification for custom follow-up ## Responding to approvals Approvers can respond in three ways: * **Email:** Click the approval buttons directly in the notification email. * **Power Automate portal:** Find pending approvals under **Action items** > **Approvals**. * **Microsoft Teams:** With 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 more complex Tallyfy [processes](/products/pro/tracking-and-tasks/processes/), you have two patterns: * **Sequential approvals:** The request moves from one approver to the next in order. * **Parallel approvals:** Requests go to multiple people at once for simultaneous review. Combine these patterns to build approval routes that match how your organization works. ## Tips for Tallyfy approval workflows * **Define clear criteria:** Know which Tallyfy event starts an approval and who the approvers are. * **Include context:** 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 so approvers have the full picture. * **Close the loop:** Always push the approval outcome back to the original Tallyfy [task](/products/pro/tracking-and-tasks/tasks/) or [process](/products/pro/tracking-and-tasks/processes/) using the Tallyfy connector's comment action. * **Keep it simple:** For basic approvals, use Tallyfy's built-in task assignments. Reserve Power Automate for multi-level approvals, external reviewers, or conditional routing. - **[Connecting Power Automate to external data sources](https://tallyfy.com/products/pro/integrations/middleware/power-automate/connecting-power-automate-to-external-data/)**: Power Automate bridges Tallyfy with SQL databases and Microsoft Forms. Automatically log task completions to database tables for reporting, or launch Tallyfy processes from form submissions by mapping responses to kick-off fields. Power Automate can connect Tallyfy to your databases and forms. Push data into Tallyfy, pull it out for reports, or trigger workflows when external systems change. This article covers two scenarios: connecting SQL databases to Tallyfy and using Microsoft Forms responses to launch Tallyfy [processes](/products/pro/tracking-and-tasks/processes/). Tallyfy also offers direct integration 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/). ## Working with databases (e.g. SQL Server) * **Why connect Tallyfy to a database via Power Automate?** * **Log Tallyfy data for reporting** - Automatically write completed [process](/products/pro/tracking-and-tasks/processes/) or [task](/products/pro/tracking-and-tasks/tasks/) details into a SQL database for reporting beyond what [Tallyfy Analytics](/products/pro/integrations/analytics/) provides. * **Archive Tallyfy details** - Store [task](/products/pro/tracking-and-tasks/tasks/) information including [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) data in a data warehouse. * **Trigger Tallyfy from database events** - When a new record appears (e.g. a new customer in your CRM database), launch a Tallyfy onboarding [template](/products/pro/documenting/templates/) automatically. * **SQL Server connector in Power Automate:** The SQL Server [connector](/products/pro/integrations/middleware/power-automate/understanding-power-automate-basics/) provides: * **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. * **Example: logging Tallyfy task completion to SQL** ## Using Microsoft Forms to launch Tallyfy processes Microsoft Forms gives users a simple front-end. They fill out a form, Power Automate launches the right Tallyfy process. * **Why use Microsoft Forms with Tallyfy?** * **Simple process initiation** - Users submit a Form (e.g. an IT support request) that launches a Tallyfy [template](/products/pro/documenting/templates/). * **Data collection** - Collect information through a Form and populate [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 kick-off form. * **Feedback loops** - Gather feedback about a completed [process](/products/pro/tracking-and-tasks/processes/) and link it back to the specific Tallyfy process instance. * **Microsoft Forms connector:** (see [understanding Power Automate basics](/products/pro/integrations/middleware/power-automate/understanding-power-automate-basics/)) * **Trigger:** `When a new response is submitted`. * **Action:** `Get response details`. * **Example: launch a Tallyfy process from a Form submission** ## Gathering user input in manual flows (recap) [Button flows](/products/pro/integrations/middleware/power-automate/triggering-flows-manually-button-flows/) can also collect external data. When someone clicks a button flow and enters "Client Name" and "Issue Description," Power Automate can instantly create a [task](/products/pro/tracking-and-tasks/tasks/) in your Tallyfy support [process](/products/pro/tracking-and-tasks/processes/). ## Tips for data integration * **Data type compatibility** - 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. * **Log Tallyfy identifiers** - Always store Process ID or Task ID when sending data to external systems, so it's easy to trace records later. * **Inspect with "Compose"** - Use a "Compose" action (see [data operations and variables](/products/pro/integrations/middleware/power-automate/working-with-data-operations-and-variables/)) to inspect payloads during testing. * **Use the [Open API](/products/pro/integrations/open-api/) when needed** - Power Automate's HTTP action with Tallyfy's [Open API](/products/pro/integrations/open-api/) handles scenarios the connector doesn't cover. - **[Connect Tallyfy to Power Automate](https://tallyfy.com/products/pro/integrations/middleware/power-automate/how-can-i-integrate-tallyfy-with-microsoft-power-automate/)**: Tallyfy's Premium connector for Microsoft Power Automate lets you link Tallyfy with Office 365 and thousands of other apps. Search for Tallyfy in Power Automate and sign in with OAuth 2.0 to automate workflows in both directions. ## Setting up the Tallyfy connection You can connect Tallyfy to Microsoft Power Automate (formerly Flow) in just a few minutes. The official Tallyfy connector -- a Premium-tier connector on Microsoft's marketplace -- links Tallyfy with Microsoft tools and thousands of other business apps, so you can automate workflows between Tallyfy and the other tools your team relies on. ### Why connect Tallyfy with Power Automate? - **Microsoft tools access** -- Link Tallyfy with Office 365, Dynamics, SharePoint, and other Microsoft products. - **Visual workflow builder** -- Create [automations](/products/pro/documenting/templates/automations/) for Tallyfy using Power Automate's drag-and-drop interface. - **Data flows in both directions** -- Send data to and pull information from your Tallyfy [processes](/products/pro/tracking-and-tasks/processes/). - **Conditional logic** -- Build decision-based flows that react to Tallyfy data. - **OAuth 2.0 [security](/products/pro/compliance/)** -- The connector uses secure OAuth authentication to protect your Tallyfy connection. ### How to set up the connection Power Automate stores your connection securely after setup. You won't need to sign in again -- just reuse the same connection across all your flows. ### Walkthrough video Here's how the connection process works: ### Going further For advanced scenarios, check out the [Tallyfy Open API](/products/pro/integrations/open-api/) and [webhooks](/products/pro/integrations/webhooks/) documentation. Microsoft also publishes [official connector docs](https://learn.microsoft.com/en-us/connectors/tallyfy/) with details on all 13 available actions, including launching processes, completing tasks, managing assignees, and updating form fields. - **[Create your first Power Automate flow](https://tallyfy.com/products/pro/integrations/middleware/power-automate/creating-your-first-flow-in-power-automate/)**: Build a Power Automate flow that monitors your Outlook inbox for emails with a specific subject line and automatically creates a task in Tallyfy with the email content mapped in so no lead gets lost. ## Create your first Power Automate flow You can connect Power Automate to Tallyfy in about 10 minutes. This guide walks you through building a flow that creates Tallyfy tasks whenever you get specific emails. Why email-to-task? It's practical, you'll use it right away, and it teaches the basics for more advanced integrations. ## Prerequisites Before you start, make sure you have: * **Microsoft Power Automate access** -- most Microsoft 365 subscriptions include this. * **A Tallyfy Pro account** -- you'll connect it through 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/). ### What does this flow do? 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 creates a task in Tallyfy. No more copy-pasting from emails. No forgotten leads. The flow catches every matching email and turns it into a trackable [task](/products/pro/tracking-and-tasks/tasks/) with the email subject and body content. ## How the flow works Here's the full path from email arrival to task creation in Tallyfy. [Diagram removed for brevity] ### What to notice - **Step 4** -- only emails with "New Sales Lead Received" trigger the flow, so you won't create tasks from every email - **Steps 6-7** -- the connector authenticates via OAuth2 using your Tallyfy Organization ID to connect Power Automate securely - **Step 10** -- confirms the task was created in Tallyfy with the email content mapped in ## Steps to create the flow ## The flow designer UI You'll spend most of your time in the flow designer. Here's what matters: * **Triggers and actions** -- triggers start the flow, actions do the work. * **Dynamic content pane** -- shows data from previous steps (like the email subject) that you can drop into Tallyfy fields. * **Expression editor** -- for date math and text manipulation. (See [advanced conditions and expressions](/products/pro/integrations/middleware/power-automate/advanced-conditions-and-expressions/)). * **Save, Test, Flow Checker** -- save often, test everything. ## Testing your flow Make sure it works before you rely on it. ## Tips for Tallyfy flows * This email-to-task pattern captures every important request in your Tallyfy [processes](/products/pro/tracking-and-tasks/processes/) so nothing slips through. * The Tallyfy [connector](/products/pro/integrations/middleware/power-automate/how-can-i-integrate-tallyfy-with-microsoft-power-automate/) has other actions too -- **Launch a Process**, **Complete task**, **Edit task deadline**, **Add comment**, and more. * Think about other emails that trigger work. Support tickets? Purchase orders? They can all flow into Tallyfy automatically. * Need something the connector doesn't cover? Tallyfy's [Open API](/products/pro/integrations/open-api/) handles advanced use cases. - **[Integrating Power Automate approvals with Microsoft Teams](https://tallyfy.com/products/pro/integrations/middleware/power-automate/integrating-power-automate-approvals-with-microsoft-teams/)**: Route Power Automate approval notifications into Microsoft Teams as interactive Adaptive Cards. Approvers can approve or reject Tallyfy process requests without leaving Teams, and responses flow back to update the original task. If your team lives in Microsoft Teams, you can route Power Automate approval notifications for Tallyfy items directly into Teams. Approvers respond using interactive Adaptive Cards without switching apps, so [processes](/products/pro/tracking-and-tasks/processes/) keep moving. Tallyfy has built-in approval features, but this integration makes sense when Teams is your team's primary workspace. ## Why integrate Power Automate approvals with Teams? * **Centralized notifications** - Approvers see and respond to requests without leaving Teams. * **Less context switching** - No more checking email for Tallyfy-related approvals routed through Power Automate. * **Faster responses** - Approvals that appear in Teams get answered in minutes instead of hours, keeping your Tallyfy [processes](/products/pro/tracking-and-tasks/processes/) and [tasks](/products/pro/tracking-and-tasks/tasks/) on track. * **Team visibility** - Post approval requests to a Teams channel so the whole team can see them. ## Prerequisites * **Power Automate approvals set up** - You should already know how to create approval workflows in Power Automate (see [building approval workflows with Power Automate](/products/pro/integrations/middleware/power-automate/building-approval-workflows-with-power-automate/)). * **Microsoft Teams with Power Automate app** - Everyone involved in approvals needs Microsoft Teams and the Power Automate app (also called the "Flow bot" - see [understanding Power Automate basics](/products/pro/integrations/middleware/power-automate/understanding-power-automate-basics/)) installed. ## Posting approval requests to Teams Use Microsoft Teams connector actions in Power Automate to send approval requests to users or channels. **Adaptive Cards** work best here. * **Adaptive Cards** - Interactive widgets in Teams that show approval details with "Approve" and "Reject" buttons built in. * **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` (for simpler scenarios) **Example: adding Teams to a Tallyfy budget approval flow** Say you already have a Power Automate flow using "Start and wait for an approval" for a Tallyfy budget request (covered in the [building approval workflows](/products/pro/integrations/middleware/power-automate/building-approval-workflows-with-power-automate/) article). Here's how to add Teams notifications: When your flow runs, the approver gets an Adaptive Card in Teams with approve and reject buttons - no app switching needed. ## Approval flow visualization [Diagram removed for brevity] **What to notice:** - The flow pauses at step 5 while waiting for the approver's response - this asynchronous "wait" is what makes the integration work - The Adaptive Card in Teams (step 3) contains approval details and action buttons, so the approver never leaves Teams - The round-trip from Tallyfy event to final update happens entirely within Teams for the approver ## Handling responses from Teams approvals * **Using "Start and wait for an approval"** - The simplest path. The flow pauses until the approver clicks a button in Teams. The response comes back automatically, and you use the `Outcome` and `Comments` outputs to update the Tallyfy [task](/products/pro/tracking-and-tasks/tasks/) or [process](/products/pro/tracking-and-tasks/processes/) via the Tallyfy connector actions. * **Custom Adaptive Cards with `Action.Submit`** - If you built a custom card, you'll need a separate flow or additional logic to match the response back to the original Tallyfy item. For most Tallyfy scenarios, stick with the standard "Start and wait for an approval" action and its `Teams Adaptive Card` output. ## Notifying users in Teams about Tallyfy events Approvals are just one use case. The Microsoft Teams connector in Power Automate can send any Tallyfy-related notification: * **Tallyfy task overdue** - Create a scheduled flow that checks task statuses through Tallyfy's [API](/products/pro/integrations/open-api/) or responds to a [webhook](/products/pro/integrations/webhooks/). When a [task](/products/pro/tracking-and-tasks/tasks/) is past its deadline, post to a Teams channel and tag the assignee. * **Tallyfy process completion** - When someone finishes the "New Client Onboarding" [process](/products/pro/tracking-and-tasks/processes/), use the Teams connector to post a notification in your project channel. (Note: the Tallyfy Power Automate connector provides actions only, not triggers - so you'll need a webhook or scheduled check to detect the event.) * **New Tallyfy task assignment** - Send the assignee a Teams DM with task details and a direct link so they see it immediately. ## Best practices * **Keep cards clear** - Show only essential details in Adaptive Cards. Always include a link back to the Tallyfy [task](/products/pro/tracking-and-tasks/tasks/) or [process](/products/pro/tracking-and-tasks/processes/). * **Verify Flow bot access** - Confirm everyone involved has the Power Automate app installed in Teams before going live. * **Test end-to-end** - Run through the full Tallyfy-to-Teams flow before rolling it out. * **Target notifications** - Send individual approvals as DMs. Post team-wide Tallyfy updates to channels. * **Avoid duplication** - Tallyfy already has built-in notifications. Only add Teams notifications where they genuinely speed up response times for your [processes](/products/pro/tracking-and-tasks/processes/). - **[RPA with Power Automate](https://tallyfy.com/products/pro/integrations/middleware/power-automate/introduction-to-rpa-with-power-automate/)**: Power Automate Desktop lets Tallyfy connect with legacy desktop apps that don't have APIs. Software bots mimic human interactions like clicking and typing through an on-premises gateway between cloud flows and desktop automation. Some desktop applications your organization relies on don't have APIs. They're old, they're clunky, and they aren't going anywhere. Robotic Process Automation (RPA) lets you connect these systems to Tallyfy by having software bots interact with their user interfaces -- clicking buttons, typing text, and moving through menus the way a person would. Power Automate Desktop is Microsoft's tool for building these automations. ## What is RPA? RPA uses software bots to automate repetitive tasks by mimicking human interactions with applications. Unlike [API](/products/pro/integrations/open-api/)-based connections (Tallyfy's preferred approach), an RPA bot works at the screen level -- it clicks, types, and moves through menus. It's a fallback for when target systems don't have accessible APIs or when API development costs too much for the task at hand. Two types: * **Attended RPA:** Runs alongside a user on their workstation, often started by them to handle part of a task. * **Unattended RPA:** Runs independently on a dedicated machine. Good for batch-processing jobs tied to Tallyfy. ## Power Automate Desktop Power Automate Desktop is where you design RPA flows (called desktop flows). It gives you a visual designer and pre-built actions for interacting with desktop apps. Key features: * **UI element recorder:** Captures mouse clicks and keyboard inputs to generate flow steps. * **UI element selector:** Pinpoints specific UI elements so the bot can reliably find them. * **Pre-built actions:** A library covering common desktop operations. * **Variable passing:** Takes input from [cloud flows](/products/pro/integrations/middleware/power-automate/understanding-power-automate-basics/) (which might pull data from Tallyfy) and passes output back. ## When to consider RPA with Tallyfy RPA is a last resort. Use it only when API-based integration isn't feasible: * **Bridging Tallyfy with legacy systems:** Your Tallyfy [process](/products/pro/tracking-and-tasks/processes/) needs data from that old on-premises desktop app with no [API](/products/pro/integrations/open-api/) -- say, a 15-year-old accounting system. RPA can handle those interactions. * **Data entry from Tallyfy to legacy apps:** Data from Tallyfy [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) gets typed into a legacy desktop app automatically. Customer details from a completed onboarding [task](/products/pro/tracking-and-tasks/tasks/) could go straight into an old CRM. * **Extracting data for Tallyfy:** An RPA bot logs into a legacy system, scrapes data, and a [cloud flow](/products/pro/integrations/middleware/power-automate/understanding-power-automate-basics/) feeds it into a Tallyfy [process](/products/pro/tracking-and-tasks/processes/). If a system offers an API, use that instead. APIs via Power Automate's HTTP connector are far more stable than RPA. Tallyfy's [Open API](/products/pro/integrations/open-api/) and [webhooks](/products/pro/integrations/webhooks/) are always your best bet for direct integration. ## Core desktop flow concepts When building desktop flows that work with Tallyfy data (passed from a cloud flow): * **UI elements:** The specific buttons, fields, and menus your bot interacts with. * **Recorder:** Translates your manual actions into flow steps -- usually needs refinement afterward. * **Actions:** Built-in operations like "Launch application," "Click UI element in window," and "Populate text field in window." * **Input/Output variables:** How desktop flows connect with [cloud flows](/products/pro/integrations/middleware/power-automate/understanding-power-automate-basics/). Inputs let a cloud flow pass Tallyfy data *into* the desktop flow. Outputs send results *back* to update Tallyfy. ## Example: updating a legacy CRM from Tallyfy data Here's a conceptual outline. A Tallyfy "Client Information Update" [task](/products/pro/tracking-and-tasks/tasks/) is completed with a new phone number in its [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/). That data needs to go into a legacy desktop CRM that has 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, steps 7-12 run on your local machine or server - **Data handoff at step 5** -- The gateway bridges cloud and desktop, passing Tallyfy form data as input variables - **UI automation sequence** -- Steps 7-12 show the RPA bot mimicking human clicks and keystrokes in the legacy CRM **1. Cloud flow (Power Automate):** **2. Desktop flow (Power Automate Desktop):** ## Setup requirements * **Power Automate Desktop:** Install it on the machine where the RPA bot will run. * **On-premises data gateway:** Required for [cloud flows](/products/pro/integrations/middleware/power-automate/understanding-power-automate-basics/) to kick off *unattended* desktop flows on an on-premises machine. It's a bridge for secure communication between cloud and desktop. ## Things to watch out for * **Fragility:** UI automation breaks when the legacy app's interface changes. Even a button moving to a different spot can kill your flow. Budget for regular maintenance. * **Error handling:** Build solid error handling into your desktop flows. See [managing and monitoring flows](/products/pro/integrations/middleware/power-automate/managing-and-monitoring-power-automate-flows/) for guidance. * **Security:** Be careful with credentials in desktop flows, especially for unattended bots. * **Check alternatives first:** Before committing to RPA, look for undocumented APIs, file import/export, or database connections. These are more reliable for Tallyfy integrations. * **Don't RPA Tallyfy itself:** Tallyfy has a full [API](/products/pro/integrations/open-api/) and [webhooks](/products/pro/integrations/webhooks/). Use those for direct integration -- save RPA for the legacy apps that have no other option. - **[Managing and monitoring Power Automate flows](https://tallyfy.com/products/pro/integrations/middleware/power-automate/managing-and-monitoring-power-automate-flows/)**: Share, export, import, and troubleshoot Power Automate flows connected to Tallyfy. Covers co-ownership, run history monitoring, and debugging tools like the flow checker and peek code. Once you've built Power Automate flows that connect to Tallyfy [processes](/products/pro/tracking-and-tasks/processes/), you'll want to keep them running smoothly. Here's how to handle collaboration, backups, migrations, and troubleshooting. ## Sharing and collaborating on flows Automating Tallyfy [processes](/products/pro/tracking-and-tasks/processes/) is rarely a solo effort. Power Automate's sharing features let teammates build, test, and maintain flows together - and keep things running when people change roles. * **Why share flows?** * **Team collaboration:** Multiple people can work on the same flow, test it, and improve it together. * **Business continuity:** If the original creator leaves, shared ownership keeps your automations running. * **Adding co-owners:** * Add other users or Microsoft 365 groups as co-owners of a cloud flow. * Co-owners get full permissions - editing, run history, managing connections (including the [Tallyfy connector](/products/pro/integrations/middleware/power-automate/how-can-i-integrate-tallyfy-with-microsoft-power-automate/)), and adding or removing other owners. * To add a co-owner: go to **My flows**, select the flow, click **Share**, and type the person's name or email. * **Connection sharing:** When you share a flow, its connections (Tallyfy, Outlook, SharePoint) become available to co-owners *only for that flow*. They can't reuse those connections elsewhere. * **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 - say, starting a Tallyfy [process](/products/pro/tracking-and-tasks/processes/) with a button click - but can't view or edit the flow itself. * To set this up: go to the flow's details page, find **Run only users**, 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 - share them with run or co-owner permissions through the Power Automate web portal. ## Exporting and importing flows Exporting and importing flows is useful for backups, moving between environments, and sharing automation solutions with other teams. * **Why export/import?** * **Backup and recovery:** Export your Tallyfy integrations regularly - you'll be glad you did when something goes wrong. * **Environment migration:** Move flows from test to production without rebuilding from scratch. * **Sharing solutions:** Package a flow with its dependencies to share across your organization. * **Exporting a flow:** 1. Go to **My flows**, find the flow, click the ellipsis (...), and select **Export** > **Package (.zip)**. 2. Give your package a **Name** and **Description**. 3. Under "Review Package Content," choose whether to update existing items or create new ones on import. 4. Click **Export** to download the .zip file. * **Importing a flow:** 1. Go to **My flows** and click **Import**, then upload the .zip package. 2. Configure each resource: choose **Create as new** or **Update an existing flow** for the flow itself, and pick existing or new connections (including your [Tallyfy connector](/products/pro/integrations/middleware/power-automate/how-can-i-integrate-tallyfy-with-microsoft-power-automate/)). 3. Once everything shows green checkmarks, click **Import**. ## Monitoring flow run history The run history tells you whether your Tallyfy automations are actually working. Access it through the [Power Automate interface](/products/pro/integrations/middleware/power-automate/understanding-power-automate-basics/). * **Accessing run history:** Click a flow name in **My flows** to see its details page, or click the ellipsis (...) and select **Run history**. * **What each run shows:** Start time, duration, and status (`Succeeded`, `Failed`, `Cancelled`, or `Running`). * **Drilling into a run:** Click any run's start time to see step-by-step details. * Expand each step to view **Inputs** and **Outputs**. * For Tallyfy actions (like "Create Task" through the [Tallyfy connector](/products/pro/integrations/middleware/power-automate/how-can-i-integrate-tallyfy-with-microsoft-power-automate/)), you'll see exactly what data was sent and what Tallyfy returned. * **Resubmitting failed runs:** If a service hiccup caused a failure, you can often resubmit the failed run with the same input data from the history page. ## Basic troubleshooting If something isn't working, here's how to troubleshoot. (New to Power Automate? Start with [the basics](/products/pro/integrations/middleware/power-automate/understanding-power-automate-basics/).) * **Flow checker:** Before running, click the **Flow checker** (stethoscope icon) to catch errors early. * **Common error types and solutions:** * **Authentication errors (401/403):** Your credentials likely expired. Edit the flow, find the failing connection (your [Tallyfy connector](/products/pro/integrations/middleware/power-automate/how-can-i-integrate-tallyfy-with-microsoft-power-automate/), Outlook, or SharePoint), and re-authenticate. The Tallyfy connector uses OAuth 2.0, so re-authenticating refreshes your tokens. * **Action configuration errors:** Missing required fields or wrong data types. Check the failed action's inputs in run history and verify everything matches. For complex data, 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 produces wrong results. 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 inspect what your expressions actually produce. * **API throttling:** Too many calls too fast will get throttled. Add delays between actions and check the [API](/products/pro/integrations/open-api/) docs for rate limits. * **Interpreting error messages:** Run history error messages usually tell you what went wrong - read them carefully before diving deeper. * **"Peek code" and "Compose" for debugging:** * **Peek code:** Click the ellipsis (...) on any action and select **Peek code** to see its JSON structure. Useful for checking how data gets sent to Tallyfy. * **Compose action:** Add a Compose action ([details here](/products/pro/integrations/middleware/power-automate/working-with-data-operations-and-variables/)) to inspect what any expression or dynamic content actually produces at runtime. ## Best practices for managing flows * **Clear naming:** Give flows and actions descriptive names. "Tallyfy New Employee Onboarding" beats "Flow 1" every time. * **Regular review:** Check run history weekly for critical flows, especially those automating key 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/) secure. Consider service accounts for flows that shouldn't depend on individual user accounts. * **Failover planning:** Set up alerts for critical flow failures and document manual workarounds as a safety net. - **[Managing files with Power Automate](https://tallyfy.com/products/pro/integrations/middleware/power-automate/managing-files-with-power-automate/)**: Power Automate can automatically manage files tied to Tallyfy workflows. Archive documents to SharePoint or OneDrive when tasks complete, or launch processes when files appear in monitored folders. ## Manage files with Power Automate Documents get created, shared, and archived constantly throughout your [processes](/products/pro/tracking-and-tasks/processes/). Power Automate handles the file shuffling so you don't have to - keeping documents organized and connected to your business systems automatically. ### Which file connectors work best with Tallyfy? These [connectors](/products/pro/integrations/middleware/power-automate/understanding-power-automate-basics/) pair well with Tallyfy: * **SharePoint** - great for team document collaboration within Tallyfy [processes](/products/pro/tracking-and-tasks/processes/) * **OneDrive for Business** - works when individuals need personal files synced with Tallyfy Dropbox, Google Drive, and FTP connectors also work. The concepts stay the same. **SharePoint/OneDrive triggers** that matter for file automation: * `When a file is created (properties only)` - fires when someone drops a document into a monitored library * `When a file is created or modified (properties only)` * `When a file is created in a folder` **SharePoint/OneDrive actions** you'll use often: * `Create file`, `Copy file`, `Move file` * `Get file content`, `Get file properties`, `Delete file` > The Tallyfy connector itself doesn't include file-specific actions. You'll use SharePoint or OneDrive connectors for file operations, combined with Tallyfy [webhooks](/products/pro/integrations/webhooks/) and the Tallyfy connector's task/process actions. ## Use cases for file management with Tallyfy Here's where file automation makes your Tallyfy [processes](/products/pro/tracking-and-tasks/processes/) genuinely better: * **Archiving documents on task completion** - 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/). A Tallyfy [webhook](/products/pro/integrations/webhooks/) fires, Power Automate catches it and archives the file to SharePoint automatically. * **Creating Tallyfy tasks from file events** - Drop a new contract in SharePoint, and Power Automate uses the Tallyfy connector's **Create Task** action to add a "Review Contract" [task](/products/pro/tracking-and-tasks/tasks/) with the file link included. * **Launching processes from file uploads** - Someone saves a sales proposal to a monitored OneDrive folder. Power Automate spots it and uses the Tallyfy connector's **Launch a Process** action to start your "Sales Proposal Review" [template](/products/pro/documenting/templates/) - with the file link pre-populated in the kick-off form. ## Building an example file management flow Here's a practical example. Your "Project Completion" [process](/products/pro/tracking-and-tasks/processes/) has a final [task](/products/pro/tracking-and-tasks/tasks/) where users upload a closure report PDF. You want that report automatically archived to SharePoint when they're done. ## Tips for file automation with Tallyfy * **Organize your folders first.** Keep SharePoint/OneDrive structures clear before building flows - it makes setup much easier. * **Check permissions early.** Your Power Automate connection needs the right access for file operations. Verify this before building your flow. * **Use consistent file names.** Include the Tallyfy [process](/products/pro/tracking-and-tasks/processes/) or [task](/products/pro/tracking-and-tasks/tasks/) ID in filenames (like `ProcessID_ReportName.pdf`) so files stay traceable. * **Prefer webhooks over polling.** Tallyfy's [webhooks](/products/pro/integrations/webhooks/) and [Open API](/products/pro/integrations/open-api/) give you precise control over when flows trigger - more reliable than monitoring folders. * **Add error handling.** Files go missing. Formats get weird. Build error handling into your flows so they don't fail silently. - **[Triggering flows manually (button flows)](https://tallyfy.com/products/pro/integrations/middleware/power-automate/triggering-flows-manually-button-flows/)**: Instant (button) flows in Power Automate let you manually trigger automations on demand, like logging a sales lead by pressing a button that collects input fields and launches a Tallyfy process template with that data in seconds from your phone or web portal. Most Power Automate flows run automatically. But sometimes you need to kick off an automation manually - right when you need it. These are **instant flows** (also called **button flows**) because you trigger them by pressing a button in the Power Automate mobile app or web portal. ## What are instant (button) flows? Instant flows are workflows you start manually to perform actions in Tallyfy. No waiting for external events. Press the button, they run. They're perfect for: * **Ad-hoc [tasks](/products/pro/tracking-and-tasks/tasks/):** Irregular actions you still want to standardize * **Quick one-click actions:** Repetitive work you're tired of doing manually * **Flows needing user input:** When you need to collect 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/): * **Launch [processes](/products/pro/tracking-and-tasks/processes/) in seconds** - start any [template](/products/pro/documenting/templates/) right from your phone, collecting initial info through the flow's input fields * **Log quick tasks** - instantly add follow-up [tasks](/products/pro/tracking-and-tasks/tasks/) to your [Tasks view](/products/pro/tracking-and-tasks/tasks-view/) or drop a one-off task into an active [process](/products/pro/tracking-and-tasks/processes/) * **Collect data on the fly** - gather information through input fields, then pass it to Tallyfy's **Launch a Process** action as the process name or summary ## Example - log sales leads into Tallyfy Here's a walkthrough: a button flow that logs new sales leads. You'll enter the lead's name, email, and source. The flow then launches your "Sales Lead Intake" [template](/products/pro/documenting/templates/) in Tallyfy. ## Running your button flow Two ways to run it: * **Web portal:** Go to **My flows**, find your flow, click **Run**, fill in the inputs, and click **Run flow** * **Mobile:** Open the Power Automate app, tap **Buttons**, find your flow, tap it, and enter the details That's it. The flow launches your Tallyfy [process](/products/pro/tracking-and-tasks/processes/) and sends you a notification (if you set one up). ## Tips for button flows * **Keep inputs minimal.** Fewer fields mean faster execution on mobile. Nobody likes typing on phones * **Name them clearly.** "Log Sales Lead" beats "Flow 1" every time * **Stack actions.** After the Tallyfy action, add an email or Teams notification - get more done with one button press * **Consider automation first.** Could this run automatically instead? A scheduled or event-based trigger sometimes makes more sense than another button to remember - **[Power Automate basics](https://tallyfy.com/products/pro/integrations/middleware/power-automate/understanding-power-automate-basics/)**: Power Automate connects Tallyfy to your other business apps using triggers and actions to launch processes and create tasks from external events. Tallyfy handles the human side of workflow management while Power Automate covers system-to-system automation. ## What are the Power Automate basics for Tallyfy integration? Power Automate connects Tallyfy with the other business apps you use daily. It handles file syncing, notifications, data collection, and repetitive tasks - so your tools work smoothly with Tallyfy [processes](/products/pro/tracking-and-tasks/processes/) and you spend less time on manual work. Here's a quick example: when a client email arrives with a contract attachment, Power Automate saves that file to SharePoint and creates a Tallyfy [task](/products/pro/tracking-and-tasks/tasks/) for your legal team to review it. That's a trigger (the email arriving) followed by actions (saving the file, creating the task). Tallyfy stays your go-to for managing [processes](/products/pro/tracking-and-tasks/processes/) and making sure people complete their work. Power Automate handles the automation *around* those processes - connecting Tallyfy to the rest of your systems. ### Why should I integrate Power Automate with Tallyfy? Tallyfy helps people work through structured [processes](/products/pro/tracking-and-tasks/processes/) together - defining steps, tracking progress, and collaborating. Power Automate picks up the system-to-system work that happens before, during, or after your Tallyfy workflows. Together, Tallyfy covers the human side and Power Automate covers the automation side. Here's what that looks like in practice: * **Launch Tallyfy workflows from external events:** When a new lead lands in your CRM (like Salesforce or HubSpot), a Power Automate flow can automatically launch a Tallyfy [template](/products/pro/documenting/templates/) such as "New Client Onboarding." * **Update external systems based on Tallyfy progress:** When someone completes a [task](/products/pro/tracking-and-tasks/tasks/) like "Invoice Approved" in Tallyfy, a Power Automate flow (triggered by a Tallyfy [webhook](/products/pro/integrations/webhooks/)) can update your accounting software (e.g., QuickBooks, Xero). * **Extend notifications:** Tallyfy has its own notifications, but Power Automate can go further - sending an SMS to a field technician when Tallyfy assigns an urgent task, or posting to a Microsoft Teams channel based on a Tallyfy event. Tallyfy has a dedicated [connector for Power Automate](/products/pro/integrations/middleware/power-automate/how-can-i-integrate-tallyfy-with-microsoft-power-automate/) with 13 actions (like creating tasks and launching processes). It uses OAuth 2.0 authentication and is a Premium tier connector. You can also check the [Tallyfy Connector page on Microsoft Learn](https://learn.microsoft.com/en-us/connectors/tallyfy/). > **Important** - The Tallyfy connector provides actions only, not triggers. To start a Power Automate flow from a Tallyfy event, use Tallyfy [webhooks](/products/pro/integrations/webhooks/) paired with Power Automate's "When an HTTP request is received" trigger. ## Core Power Automate terminology for Tallyfy users These are the Power Automate terms you'll need for your Tallyfy integration: * **Flows:** The core unit of Power Automate - an automated workflow with a trigger and one or more actions. * **Cloud flows:** Run in Microsoft's cloud. * *Automated flows:* Start when a specific event happens. For example, a Tallyfy [webhook](/products/pro/integrations/webhooks/) can fire when a task completes, triggering an automated flow via the HTTP connector. * *Instant flows (button flows):* Started manually with a button click. A sales rep could use one to quickly launch a Tallyfy "Client Demo Request" [process](/products/pro/tracking-and-tasks/processes/). Learn more about [triggering flows manually](/products/pro/integrations/middleware/power-automate/triggering-flows-manually-button-flows/). * *Scheduled flows:* Run at set times. For example, a daily flow that checks for overdue Tallyfy [tasks](/products/pro/tracking-and-tasks/tasks/) and sends a summary to a manager. * **Desktop flows:** Used for Robotic Process Automation (RPA) on Windows desktops. See our article on [RPA with Power Automate](/products/pro/integrations/middleware/power-automate/introduction-to-rpa-with-power-automate/). * **Connectors:** Bridges that let Power Automate talk to different apps. The [Tallyfy connector](/products/pro/integrations/middleware/power-automate/how-can-i-integrate-tallyfy-with-microsoft-power-automate/) provides 13 actions for your Tallyfy account. Other connectors cover Microsoft services (Outlook, SharePoint) and third-party apps. * **Triggers:** The event that starts a flow. Examples: "When a new email arrives" (Outlook connector) or "When a file is created" (SharePoint connector). For Tallyfy events, you'd use Tallyfy [webhooks](/products/pro/integrations/webhooks/) with Power Automate's HTTP request trigger - the Tallyfy connector itself doesn't include triggers. * **Actions:** Operations a flow performs after it's triggered. The Tallyfy connector's actions include creating tasks, launching processes, completing tasks, and adding comments. * **Conditions:** Let your flows make decisions based on data, including data from Tallyfy. Covered in [using conditional logic in Power Automate](/products/pro/integrations/middleware/power-automate/using-conditional-logic-in-power-automate/). * **Expressions:** Formulas for advanced data manipulation. We cover these in [advanced conditions and expressions in Power Automate](/products/pro/integrations/middleware/power-automate/advanced-conditions-and-expressions/). * **Dynamic content:** Data from previous steps in your flow that you can reuse. For example, when a Tallyfy webhook fires and starts a flow, the webhook payload (task ID, name, who completed it) becomes dynamic content for later steps. ## Power Automate interfaces overview You'll work with Power Automate through three main interfaces: * **Web portal (make.powerautomate.com):** The main hub for creating, managing, and [monitoring cloud flows](/products/pro/integrations/middleware/power-automate/managing-and-monitoring-power-automate-flows/) that connect to Tallyfy. * **Mobile app (iOS and Android):** Handy for running instant (button) flows that interact with Tallyfy. * **Power Automate Desktop:** For creating and managing [desktop flows (RPA)](/products/pro/integrations/middleware/power-automate/introduction-to-rpa-with-power-automate/). ## How these concepts work together with Tallyfy Once you understand these building blocks, you can create automations that make your Tallyfy [processes](/products/pro/tracking-and-tasks/processes/) far more powerful. Here's 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 a **condition**), the flow uses the Tallyfy **connector** as an **action** to create a high-priority [task](/products/pro/tracking-and-tasks/tasks/) in your support [process](/products/pro/tracking-and-tasks/processes/). The task includes **dynamic content** from the email - sender, subject, body - everything your team needs. - **[AI Builder in Power Automate](https://tallyfy.com/products/pro/integrations/middleware/power-automate/using-ai-builder-in-power-automate/)**: AI Builder in Power Automate adds AI capabilities like text recognition and sentiment analysis to your Tallyfy workflows. Scanned documents and customer feedback get automatically processed and routed without manual data entry or coding. AI Builder is a Power Automate feature that adds AI capabilities - text recognition, sentiment analysis, document processing - to your Tallyfy automations without writing code. If your flows handle unstructured data like scanned forms, customer feedback in [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/), or images attached to [tasks](/products/pro/tracking-and-tasks/tasks/), AI Builder can interpret that content and act on it. ## What is AI Builder? AI Builder gives you pre-built AI models ready to go, and you can train custom models on your own Tallyfy data. You don't need data science experience. Where it really shines is unstructured data. Scanned forms that need to launch a [process](/products/pro/tracking-and-tasks/processes/), customer emails that should create a task, feedback text that needs routing based on tone - AI Builder handles all of it. ## Model types relevant to Tallyfy * **Pre-built models (ready to use):** Microsoft trained these, so they work immediately. * **Text Recognition (OCR):** Pulls text from images and PDFs - great for scanned forms that feed into a Tallyfy [process](/products/pro/tracking-and-tasks/processes/). * **Sentiment Analysis:** Detects positive or negative tone in text. Useful for analyzing customer feedback from Tallyfy [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) and routing accordingly. * **Key Phrase Extraction:** Finds main points in text - handy for summarizing lengthy notes from a [task](/products/pro/tracking-and-tasks/tasks/). * **Language Detection:** Identifies which language someone's writing in. Important if your [processes](/products/pro/tracking-and-tasks/processes/) handle multilingual input. * **Business Card Reader:** Grabs contact info from photos, then fills fields in your Tallyfy [process](/products/pro/tracking-and-tasks/processes/). * **Receipt Processing:** Extracts expense data from receipts into your approval [process](/products/pro/tracking-and-tasks/processes/) in Tallyfy. * **Custom models (train with your data):** These take more setup but match your specific Tallyfy use case. * **Form Processing:** Teach it to read your invoices, purchase orders, or any documents that kick off a Tallyfy [process](/products/pro/tracking-and-tasks/processes/). Handles non-standard layouts well. * **Object Detection:** 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/). * **Prediction:** Uses historical Tallyfy data to forecast outcomes, like whether a [process](/products/pro/tracking-and-tasks/processes/) will meet its SLA based on initial [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) values. * **Category Classification:** 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 get tagged automatically. ## Example: sentiment analysis on Tallyfy feedback Here's a practical walkthrough. You'll use AI Builder's Sentiment Analysis to process customer feedback collected through 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 feedback into a [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/). You want to detect whether they're happy or upset, then route the response accordingly. > The Tallyfy Power Automate connector has 13 actions and no triggers. To start a flow when a Tallyfy task completes, set up a Tallyfy webhook that calls your flow's HTTP trigger - the connector itself doesn't provide trigger events. ## Custom model example: form processing with Tallyfy Custom models take more setup but match your exact 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 in different formats from various suppliers. Each PO contains a PO Number, Customer Name, Items, and Quantities. You want these to automatically launch your "Order Fulfillment" [process](/products/pro/tracking-and-tasks/processes/) in Tallyfy - no manual data entry. ## Licensing and considerations * **Licensing:** AI Builder requires separate Power Platform credits - they aren't included with standard Power Automate licenses. Credits are consumed each time models process data. * **Effort:** Pre-built models work immediately. Custom models need sample documents from your Tallyfy [processes](/products/pro/tracking-and-tasks/processes/), careful tagging, and training time. * **Accuracy:** Custom model quality depends on training data. More varied examples produce better real-world results. ## What AI Builder adds to Tallyfy workflows * **Less manual data entry:** Documents and emails get processed automatically - extracted data flows into Tallyfy [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) without copy-paste errors. * **Content analysis at scale:** Customer comments in Tallyfy [tasks](/products/pro/tracking-and-tasks/tasks/), support notes, survey responses - AI Builder pulls out sentiment and key phrases you'd otherwise have to read manually. * **Smart routing:** AI analyzes incoming data before it reaches Tallyfy and directs it to the right [process](/products/pro/tracking-and-tasks/processes/) or team. Urgent issues get fast-tracked automatically. * **Predictive actions:** Prediction models can flag at-risk [processes](/products/pro/tracking-and-tasks/processes/) before deadlines are missed. - **[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 lets flows make decisions based on Tallyfy data - using IF-THEN structures, Switch controls, and nested conditions to route actions differently based on task statuses, form field values, and process conditions. Conditional logic makes your Power Automate flows smart. Instead of running the same actions every time, your flow checks Tallyfy data and picks a different path based on what it finds -- sending escalation emails for high-priority [tasks](/products/pro/tracking-and-tasks/tasks/), routing approvals to different teams, or skipping steps entirely when they don't apply. ## How conditional logic works with Tallyfy Your flow asks a yes-or-no question about Tallyfy data, then takes one path if true, another if false. A customer support [process](/products/pro/tracking-and-tasks/processes/) is a good example -- the flow checks a "Priority" [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) on each [task](/products/pro/tracking-and-tasks/tasks/). High priority gets escalated immediately. Low priority gets logged for routine follow-up. ## The Condition control ## Building a conditional flow with Tallyfy Here's a practical scenario: you've set up a Tallyfy webhook[^1] that fires when someone completes a task. Your Power Automate flow receives that webhook data, then sends different email notifications based on the task's priority level. ## Visualizing the conditional flow [Diagram removed for brevity] The diamond is the decision point. Two paths branch from it -- each leading to a different email action based on the form field value. ## Multiple conditions with AND/OR You'll often need to check more than one piece of Tallyfy data at once. * **Adding rows:** Inside a Condition, click **+ Add** > **Add row**. * **AND logic:** The default -- all conditions must be true. * **OR logic:** Switch the operator at the top to OR -- any single true condition is enough. *Example (AND):* IF a Tallyfy [task's](/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 deadline has passed, THEN send an escalation alert. ## Nested conditions Need 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, nest another condition to check whether the order value ([form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/)) exceeds $10,000. When nesting gets messy, switch to a Switch control instead (see [advanced conditions and expressions](/products/pro/integrations/middleware/power-automate/advanced-conditions-and-expressions/)). ## Switch control for multiple options The **Switch** control works better than nested conditions when you're checking one Tallyfy value against several options. More 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 a Tallyfy [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/)). Create multiple **CASE** branches for each possible value. The **DEFAULT** branch catches everything else. *Example:* A Tallyfy [task](/products/pro/tracking-and-tasks/tasks/) has a "Support Ticket Category" [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) with values like "Billing Issue" and "Technical Problem." * SWITCH ON "Support Ticket Category": * CASE "Billing Issue": Notify finance. * CASE "Technical Problem": Create an urgent [task](/products/pro/tracking-and-tasks/tasks/) in a Tallyfy "Tech Support" [process](/products/pro/tracking-and-tasks/processes/). * DEFAULT: Notify general support. ## Tips for conditions with Tallyfy data * **Match data types** -- use [expressions](/products/pro/integrations/middleware/power-automate/advanced-conditions-and-expressions/) like `int()` to convert Tallyfy text values when comparing against numbers. * **Handle case sensitivity** -- wrap text in `toLower()` for case-insensitive comparisons. * **Use Tallyfy connector outputs** -- data from Tallyfy [connector](/products/pro/integrations/middleware/power-automate/how-can-i-integrate-tallyfy-with-microsoft-power-automate/) actions should drive your conditional logic. * **Test every branch** -- run through each path with different Tallyfy data inputs to catch edge cases. [^1]: Tallyfy webhooks send HTTP POST requests to your flow's URL when events happen -- like task completions or process launches - **[Data operations and variables in Power Automate](https://tallyfy.com/products/pro/integrations/middleware/power-automate/working-with-data-operations-and-variables/)**: Power Automate lets you store and transform Tallyfy task data using variables, loops, and parse operations. Filter tasks by date and build formatted reports like daily HTML email summaries of due items. When you pull information from Tallyfy into Power Automate, you'll deal with collections of [tasks](/products/pro/tracking-and-tasks/tasks/), [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) data, and JSON payloads. Variables, loops, and data operations are the tools that let you store values, transform data, and process multiple items at once. ## How variables work with Tallyfy integrations Variables are temporary storage that persists while your flow runs. Here's why they matter for Tallyfy work: * Store intermediate results from Tallyfy data lookups * Count [tasks](/products/pro/tracking-and-tasks/tasks/) that match specific criteria * Build up a list of task names before sending it somewhere else * Control loop behavior based on changing Tallyfy values **Variable types** in Power Automate: Boolean, Integer, Float, String, Array, and Object. **Common variable actions:** * **Initialize variable** - declares the variable with a name, type, and starting value (always goes first) * **Set variable** - overwrites the current value * **Increment / Decrement variable** - adds or subtracts 1, great for counters * **Append to string variable** - tacks text onto the end * **Append to array variable** - pushes a new item into the list ## Looping through Tallyfy data with Apply to each The **Apply to each** control runs your actions once per item in an array. * Power Automate adds it automatically when you pick 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/)) * You can also add one manually and point it at array data from an earlier step **Tallyfy example:** Say a [task](/products/pro/tracking-and-tasks/tasks/) has a table-type [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) listing equipment for a project. When you fetch that task 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/), the table comes back as an array. Use "Apply to each" to loop through every row - maybe creating purchase orders in your ERP or adding items as tasks in another Tallyfy process. ## Parsing JSON from Tallyfy Tallyfy [webhooks](/products/pro/integrations/webhooks/) and [API](/products/pro/integrations/open-api/) responses return JSON. The **Parse JSON** data operation turns that raw text into structured objects you can reference as dynamic content. **How to set it up:** 1. Add **Parse JSON** from Data Operations 2. **Content** - point it at your JSON string from Tallyfy 3. **Schema** - click **Generate from sample** and paste real JSON from a Tallyfy webhook or API call :::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/) and your [webhook](/products/pro/integrations/webhooks/) fires a JSON payload to Power Automate. That payload contains the process name, who started it, and all kick-off form data - but it's just a text blob until you parse it. After parsing, you can grab the initiator's email, route form data to other systems, or trigger follow-up actions. **Handling Tallyfy field types after parsing:** - **Text fields** - map directly as strings - **Dropdown fields** - use `item()?['fieldName']?['text']` for the display label - **Checkbox fields** - returns an array of selected values; loop or index into it - **Table fields** - each row is an object in an array, so you'll need a loop - **Date fields** - arrives in ISO format; format with `formatDateTime()` ## Transforming Tallyfy data into CSV or HTML tables Two data operations turn arrays into formatted output: * **Create CSV Table** - feed it an array of Tallyfy task details, get back a CSV string for Excel * **Create HTML Table** - same input, outputs an HTML table you can paste into an email **Tallyfy use case:** Pull overdue [tasks](/products/pro/tracking-and-tasks/tasks/) 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/), then run them through **Create HTML Table** to email a formatted summary to team leads. ## Putting it together - a daily task report **Scenario:** Your team lead wants a daily email at 8 AM showing all their Tallyfy [tasks](/products/pro/tracking-and-tasks/tasks/) due that day, formatted as an HTML table. ## Tips for working with Tallyfy data * **Initialize early.** Put all variable initializations at the top of your flow. It's easier to maintain. * **Expect arrays everywhere.** 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 reach for "Apply to each" often. * **Debug with Compose.** Can't tell what your data looks like? Drop a "Compose" action and output your variable or Tallyfy data. It's console.log for Power Automate. - **[Email automation in Power Automate](https://tallyfy.com/products/pro/integrations/middleware/power-automate/working-with-email-automation-in-power-automate/)**: Power Automate connects email services like Outlook 365 to Tallyfy so incoming emails can automatically launch processes and populate form fields. Tallyfy events can also trigger personalized outbound emails, all without manual work. Power Automate can handle email tasks automatically and connect them to your Tallyfy [processes](/products/pro/tracking-and-tasks/processes/). You'll get data capture, actions, and notifications for your Tallyfy [tasks](/products/pro/tracking-and-tasks/tasks/) without manual work. ## Email connectors in Power Automate Power Automate offers several [connectors](/products/pro/integrations/middleware/power-automate/understanding-power-automate-basics/) for email services. **Outlook 365** is the most common. Gmail, Outlook.com, and SMTP connectors are also available. These examples use Outlook 365, but the same patterns apply across all email connectors when connecting to Tallyfy. ## Common email automation scenarios Here are the scenarios that save the most time: * **Email content triggers Tallyfy actions:** Flows watch for specific emails, extract data from the subject or body, then launch a Tallyfy [process](/products/pro/tracking-and-tasks/processes/), create a [task](/products/pro/tracking-and-tasks/tasks/), or update existing work. * *Example:* A supplier sends an invoice email. Power Automate grabs the invoice details and launches a "Process Invoice" [process](/products/pro/tracking-and-tasks/processes/) in Tallyfy. The invoice data fills your Tallyfy [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) automatically. * **Email attachments feed into Tallyfy:** Flows save attachments to SharePoint or OneDrive, then link them to the right Tallyfy [tasks](/products/pro/tracking-and-tasks/tasks/). * *Example:* A client emails a project brief. Power Automate saves it to SharePoint and launches your Tallyfy "New Project Onboarding" [template](/products/pro/documenting/templates/). The brief attaches to the first [task](/products/pro/tracking-and-tasks/tasks/) so your team sees it right away. * **Tallyfy events send automated emails:** Use Tallyfy [webhooks](/products/pro/integrations/webhooks/) to start a Power Automate flow when something happens in Tallyfy - like a [task](/products/pro/tracking-and-tasks/tasks/) completion or [process](/products/pro/tracking-and-tasks/processes/) milestone. 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 sends a personalized welcome email using the customer's name and preferences from your Tallyfy [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/). ## Building an example email automation flow Here's a practical walkthrough. We'll create a flow that watches a shared mailbox (`orders@yourcompany.com`) for emails with "New Order Request" in the subject. When one arrives, it launches your Tallyfy "New Order Processing" [template](/products/pro/documenting/templates/) with all the order details filled in. ## Best practices for email automation with Tallyfy * **Be specific with email triggers:** Use exact subject lines or sender addresses. Overly broad triggers waste your connector's [API](/products/pro/integrations/open-api/) call limit of 100 calls per minute. * **Plan your data mapping:** Decide which email parts go where before you build. Subject line to process name? Body text to a description field? Map it out first. * **Design templates for automation:** Create [templates](/products/pro/documenting/templates/) with consistent field names like "CustomerEmail" - not "email" or "Email" or "customer_email." Consistent naming prevents mapping errors. * **Add error handling:** What happens when an attachment is missing or the email format is unexpected? Build in fallbacks so your Tallyfy processes keep running. * **Test with varied inputs:** Send test emails from different accounts with different formats. Find the edge cases before your users do. ### Workato - **[Complete Tallyfy tasks from Workato](https://tallyfy.com/products/pro/integrations/middleware/workato/how-to-complete-tallyfy-tasks-from-workato/)**: Workato recipes can automatically complete Tallyfy tasks when external events happen. Send HTTP POST requests to the completed-tasks API endpoint with form field data, error handling for missing fields, and rate limit retries. ## Complete Tallyfy tasks automatically from Workato recipes You can complete [Tallyfy tasks](/products/pro/tracking-and-tasks/tasks/) from Workato recipes whenever something happens in another system - like a document getting signed or a CRM record updating. Here's how to set it up. ### Common use cases - Mark tasks complete when a document is signed in DocuSign - Complete approval tasks based on Microsoft Forms responses - Update task [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) when CRM data changes - Auto-complete tasks when ERP conditions are met ### Prerequisites - Workato account with HTTP connector access - Tallyfy API access token (from **Settings > Integrations > REST API**) - Your Tallyfy organization ID - Task IDs or a way to retrieve them dynamically ## Setting up task completion ### Step 1: Identify the task to complete You'll need the task ID and the process (run) ID. Here's how to get them: #### Option A: From a Tallyfy webhook If Tallyfy triggered your recipe via webhook: ```ruby task_id = trigger["task"]["id"] run_id = trigger["task"]["run_id"] ``` #### Option B: List tasks for a process Use an HTTP GET to retrieve tasks within a specific process: ``` GET https://go.tallyfy.com/api/organizations/{org_id}/runs/{run_id}/tasks ``` #### Option C: Store task IDs when launching When you launch a process, store the returned task IDs in a lookup table. This works well for recurring workflows. ### Step 2: Configure the completion request Task completion in Tallyfy uses a POST request (not PUT) to a `completed-tasks` endpoint[^1]. For approval tasks, you must also include `is_approved`: ```json { "task_id": "{task_id}", "is_approved": true } ``` ### Step 3: Save form field data before completing If the task has form fields that need values, save them *before* completing the task. Tallyfy stores form field values (called "captures" in the API) through a separate endpoint: ``` POST https://go.tallyfy.com/api/organizations/{org_id}/tasks/{task_id}/captures ``` Each field is saved individually with its ID and value: ```json { "id": 12345, "value": "Approved by John Smith" } ``` You'll need to call this endpoint once per field, then complete the task afterward. The field `id` comes from the task's capture definitions. ## Advanced completion scenarios ### Conditional task completion Only complete tasks when certain conditions are met: ### Bulk task completion Need to complete several tasks in a process? Here's the pattern: ### Updating form fields without completing Sometimes you want to save form field data without marking the task done - maybe you're collecting data in stages. Use the captures endpoint: ``` POST https://go.tallyfy.com/api/organizations/{org_id}/tasks/{task_id}/captures ``` ```json { "id": 67890, "value": "updated_value" } ``` You can also update other task properties (like deadline or assignees) via PUT: ``` PUT https://go.tallyfy.com/api/organizations/{org_id}/runs/{run_id}/tasks/{task_id} ``` ## Error handling ### Common errors and solutions | Error code | Meaning | Solution | |------------|---------|----------| | 401 | Unauthorized | Check your Bearer token and `X-Tallyfy-Client` header | | 403 | Forbidden | Verify the organization ID is correct | | 404 | Task not found | Confirm the task ID, run ID, and org ID are valid | | 422 | Validation failed | Required form fields probably aren't filled yet | ### Retry logic ## Recipe example: DocuSign signature triggers task completion A real-world pattern - completing a Tallyfy task when someone signs a document: ## Troubleshooting ### Task won't complete? Run through this checklist: 1. Is the task in "active" status? Completed tasks can't be completed again. 2. Are all required form fields filled? The API returns a 422 if they aren't. 3. Does the user have permission? Tasks with `can_complete_only_assignees` set need an assigned user. 4. Are there unresolved issues? Tasks with open problem threads can't be completed. ### Form data not saving? Usually one of these: 1. The field `id` must be the numeric capture ID - not the field name 2. The `value` must match the expected data type 3. Make sure the field actually exists on that task 4. Check that values meet any validation rules on the field ### Getting 429 rate limit errors? You're sending requests too fast. Fix it by: 1. Adding delays between requests 2. Using exponential backoff 3. Reducing parallel operations [^1]: Tallyfy uses POST to a `completed-tasks` resource rather than a PUT/PATCH status change, which differs from many REST APIs - **[Launch Tallyfy processes from Workato](https://tallyfy.com/products/pro/integrations/middleware/workato/how-to-launch-tallyfy-processes-from-workato/)**: Workato recipes can automatically launch Tallyfy processes from triggers in Salesforce, Zendesk, or other systems. The HTTP connector sends authenticated POST requests to Tallyfy's API with template IDs and kick-off form data mapped from the triggering event. ## Launch Tallyfy processes from Workato recipes You can connect Workato to Tallyfy's API so that events in Salesforce, Zendesk, or any other system automatically start [processes](/products/pro/tracking-and-tasks/processes/). Workato's HTTP connector sends a POST request to Tallyfy with your template ID and kick-off form data - no custom code needed. ### How the integration flows [Diagram removed for brevity] **Key points:** - Authentication (step 4) needs a Bearer token and the `X-Tallyfy-Client` header - missing either causes a 401 error - Workato maps your trigger data into the `prerun` object, keyed by each kick-off field's timeline ID, which populates those fields automatically (step 2) - Error handling (step 8) catches authentication failures, bad template IDs, or data format issues ### Prerequisites You'll need: - A Workato account with HTTP connector access - A Tallyfy account with API access - Your Tallyfy API token from **Settings > Integrations > REST API** - Your organization ID (found in **Settings > Organization**) - The template ID for the process you want to launch - The timeline ID of each kick-off form field you want to pre-fill (see Step 4) ### Step 1 - Create the HTTP connection in Workato ### Step 2 - Create a recipe to launch processes > The URL includes your organization ID as a path segment. Don't pass `organization_id` in the request body - it belongs in the URL. ### Step 3 - Configure the request body Add this JSON to the **Request body** field: ```json { "checklist_id": "YOUR_TEMPLATE_ID", "name": "Process name from trigger data", "owner_id": "USER_ID", "prerun": { "a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6": "value from trigger", "3c9d1e7fa4b820516d8e2f7a9c0b4d15": "another value" } } ``` The `checklist_id` is the template's timeline ID (what the API calls a "blueprint" internally). The `name` field sets the process title. The `owner_id` is optional - if omitted, the authenticated user becomes the owner. The keys inside `prerun` are the timeline IDs of your kick-off form fields, each a 32-character hex string. They are not the field labels or aliases. Step 4 shows how to find them. Each `prerun` value's shape depends on the field type. The per-type list lives on [Launch process](/products/pro/integrations/open-api/code-samples/processes/launch-process/). #### Mapping dynamic data Instead of hardcoding values, use Workato's Formula mode: 1. Click the **Formula** mode toggle 2. Build your JSON dynamically: ```ruby { "checklist_id": "abc123", "name": "Order " + trigger["order_number"] + " - " + trigger["customer_name"], "owner_id": "user456", "prerun": { # Customer name field "a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6": trigger["customer_name"], # Order value field "3c9d1e7fa4b820516d8e2f7a9c0b4d15": trigger["total_amount"], # Priority field "9f2b7c1e4a6d8035b1c7e9d2f4a6b801": trigger["priority"] } } ``` Keep a comment next to each ID so the recipe stays readable. Nothing in the payload tells you which field an ID belongs to. ### Step 4 - Handle kick-off form fields If your template has a [kick-off form](/products/pro/launching/triggers/kick-off-forms/), populate those fields through the `prerun` object: 1. Check which kick-off form fields are required in your template 2. Get each field's timeline ID by calling `GET https://go.tallyfy.com/api/organizations/YOUR_ORG_ID/checklists/YOUR_TEMPLATE_ID` and reading the `id` on each entry of the `prerun` array in the response. Ignore the `alias` next to it - alias keys don't work 3. Use those IDs as the keys in your `prerun` object 4. Match the value format to the field type (see the table below) The value format depends on what kind of field it is: | Field type | Value to send | |------------|---------------| | Short text, long text, email | A plain string: `"John Smith"` | | Date | An ISO 8601 string: `"2026-03-15T00:00:00.000Z"` | | Radio button | The option's text as a plain string: `"Full-time"` | | Dropdown | An object with both keys: `{ "id": 2, "text": "Engineering" }` | | Checklist (multi-select) | A list of those objects, each carrying `"selected": true`: `[{ "id": 1, "text": "Laptop", "selected": true }]` | | Table | A list with one entry per column, in column order: `["Widget", "3"]` | | Assignees | `{ "users": [], "guests": [], "groups": [] }` | Dropdown and radio look alike in the app but take different shapes here. A radio takes the bare text, a dropdown needs the `id` and `text` pair. The multi-select shape needs one extra thing: `"selected": true` on every option you're picking. Leave it off and Tallyfy still accepts the recipe step without an error, but the field renders as empty text anywhere it's used as a `{{variable}}`. Here's an example with different field types: ```json { "checklist_id": "template123", "name": "New Employee: John Smith", "owner_id": "hr_manager_id", "prerun": { "a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6": "John Smith", "3c9d1e7fa4b820516d8e2f7a9c0b4d15": "2026-03-15T00:00:00.000Z", "9f2b7c1e4a6d8035b1c7e9d2f4a6b801": { "id": 2, "text": "Engineering" }, "6e4a2c80f19b3d75e0a8c246b93f157d": "75000", "2d7f9a1c5e3b806478d0a2c4e6f81b39": "Full-time" } } ``` Reading top to bottom, that's a text field, a date, a dropdown, a text field holding a number, and a radio button. ### Step 5 - Use the Tallyfy response Tallyfy returns the created process details. You can capture these in your recipe: ### Step 6 - Add error handling ### Common integration patterns #### Launch from a CRM opportunity When a Salesforce opportunity hits "Closed Won," onboarding starts 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 #### Launch from a support ticket Route urgent tickets into a structured escalation process: 1. Trigger: Zendesk - New ticket 2. Condition: Priority = "Urgent" 3. Action: Launch Tallyfy escalation process #### Scheduled launches Run recurring processes on a schedule: 1. Trigger: Scheduler - Daily/Weekly/Monthly 2. Action: Launch Tallyfy process 3. Use date formulas for dynamic names ### Troubleshooting #### Process won't launch? - Confirm your API token is active and hasn't expired - Check that the `X-Tallyfy-Client: APIClient` header is included - Verify the template ID is the timeline ID, not the template name - Make sure the org ID in your URL is correct #### Kick-off form data not appearing? - Each key in `prerun` must be a kick-off field's timeline ID, not the field's label or alias. A key that matches no field is discarded silently, so the launch still succeeds with that field empty - Value formats need to match the field type (see the table in Step 4). A dropdown sent as bare text is rejected - Required fields can't be empty #### Getting 422 validation errors? The API returns detailed validation errors. Check the response body for a `details` object that tells you which fields failed and why. - **[Workato actions and triggers](https://tallyfy.com/products/pro/integrations/middleware/workato/workato-actions-and-triggers/)**: The Workato connector for Tallyfy grew from five actions and three triggers to a full set covering users, tasks, processes, templates, form fields, comments, tags, folders, and search, plus five polling triggers and five instant (webhook) triggers, all authenticated with OAuth 2.0. ## What the Workato connector now covers The Workato connector for Tallyfy is built to cover the same core actions as Tallyfy's other connectors, across ten categories plus ten triggers (five polling and five instant webhooks). Once it's published, you'll be able to build recipes for all of them. :::note[Not yet available to install] This connector is built but not yet published to Workato's community library, so you can't add it from inside Workato yet. The actions below describe what it will offer once it goes live. To connect Workato to Tallyfy today, use Workato's HTTP connector with [Tallyfy's REST API](/products/pro/integrations/open-api/). [Contact Tallyfy support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/) for early access. ::: ### Actions by category | Category | What you can do | |---|---| | **Users and guests** | Invite members, read and list users, change roles, enable or disable accounts, create and update guests | | **Groups** | Create, read, update, and delete groups | | **Tasks** | Create standalone tasks, complete tasks (including approvals), update, reopen, and read tasks; list tasks for yourself, another member, a guest, or a process | | **Processes** | Launch a process from a template, read, update, archive, reactivate, and list processes; submit or reopen a kick-off form | | **Templates** | Read, list, create, clone, update, and delete templates; list a template's steps and kick-off fields | | **Form fields** | Add, update, move, and delete step form fields; manage dropdown options; add, update, delete, and reorder kick-off fields | | **Comments and issues** | Add, read, edit, and delete comments; report an issue on a task and resolve it | | **Tags** | Create, update, delete, and list tags; tag or untag templates and processes | | **Folders** | Create, update, and delete folders; move templates and processes in and out | | **Search** | Keyword search across tasks, processes, templates, snippets, or everything at once | In total the connector now ships 82 actions and 10 triggers (5 polling and 5 instant), up from 5 actions and 3 triggers, backed by 5 pick lists that fill dropdowns like templates, users, and processes. :::note[Not yet included] Automation rules, step-level template edits (adding, cloning, reordering, or reassigning individual steps), and a raw API passthrough action are a later follow-up. For those, call Tallyfy's [Open API](/products/pro/integrations/open-api/) directly through Workato's HTTP connector. ::: ### Triggers (polling) Workato went from three triggers to five - it already had more working triggers than any other Tallyfy connector. Each trigger polls: it checks Tallyfy on a schedule, picks up new items, and de-duplicates by record id so nothing repeats. 1. **New process started** - a process starts, optionally scoped to one template. 2. **Task completed** - a task is marked complete. 3. **New task assigned** - a new task lands in your queue. 4. **Comment or issue added** - a comment or reported issue appears on any task in the process you choose to watch. 5. **Process completed** - a whole process reaches completed status, not just one task. Polling frequency follows your Workato plan and recipe settings. More frequent polling means fresher data and more API calls. ### Triggers (instant, webhook-based) Five more triggers deliver in real time instead of polling. Tallyfy pushes the event to your recipe the moment it happens. Each has an **(instant)** title in the trigger picker: 1. **New process launched (instant)** - fires the moment a process is launched from a template. 2. **Process completed (instant)** - fires the moment a whole process reaches completed status. 3. **Task completed (instant)** - fires the moment a task is marked complete. 4. **New task assigned (instant)** - fires the moment a task is assigned to someone. 5. **New comment or issue (instant)** - fires when a comment is added, or an issue is raised or resolved, on a task. When the recipe starts, the connector registers one organization-wide webhook with Tallyfy and removes it when the recipe stops. Tallyfy then posts every event to that webhook, and each instant trigger keeps only the events it cares about. :::note[Instant triggers need an admin connection, and the backend is rolling out] Registering an organization webhook requires an organization admin. If the connected account isn't an admin, Tallyfy returns a permission error (HTTP 403), so connect an admin account or use the matching polling trigger instead. Tallyfy's organization-webhook backend is also still rolling out to production. Until your organization has it enabled, an instant trigger may not fire, so use a polling trigger meanwhile and switch once instant delivery is live for your organization. ::: ### Authentication (OAuth 2.0) Workato connects to Tallyfy with OAuth 2.0. Contact Tallyfy support to get a Client ID and Client Secret, then create a Tallyfy connection in Workato using those credentials plus your Organization ID (find it in Settings > Organization). Tallyfy supports bearer tokens with refresh, so the connection renews itself and you won't keep re-entering credentials. ### Getting started 1. Create or open a recipe in Workato. 2. Add the Tallyfy connector and create a connection with your OAuth 2.0 Client ID, Client Secret, and Organization ID. 3. Pick an action, for example Start process, and map the input fields. 4. To react to Tallyfy events, start the recipe from one of the five polling triggers. 5. Test with sample data, then start the recipe. Remember the API terminology: "templates" in the Tallyfy UI are "checklists" in the API, and "processes" are "runs". ## AI-native alternative (Tallyfy MCP) If building recipes by hand is more than you need, the Tallyfy MCP server lets an AI assistant call these same actions in plain English. See the [MCP server](/products/pro/integrations/mcp-server/) guide. ### Zapier - **[Tallyfy and Zapier](https://tallyfy.com/products/pro/integrations/middleware/zapier/how-can-i-improve-task-management-with-tallyfy/)**: Tallyfy paired with Zapier lets your team handle the human side of work like judgment and decisions while automating repetitive tasks across apps. From CRM-triggered onboarding and scheduled process launches to turning emails and form submissions into tracked workflows with clear ownership. ## Improve task management with Tallyfy and Zapier Tallyfy handles the human side of [process](/products/pro/tracking-and-tasks/processes/) management - judgment, creativity, and decisions. Zapier handles the robotic parts. Together, they connect your apps without forcing everything into rigid automation. Your team completes [tasks](/products/pro/tracking-and-tasks/tasks/) that need human input while Zapier triggers and actions handle the repetitive work. The Tallyfy connector supports launching [processes](/products/pro/tracking-and-tasks/processes/), creating standalone tasks, completing tasks, changing assignees and deadlines, and adding comments - all from Zapier. :::note[Consider other middleware too] Zapier works for simple connections, but [middleware](/products/pro/integrations/middleware/) tools like **n8n**, **Make**, or **Microsoft Power Automate** often handle more advanced [integrations](/products/pro/integrations/) at lower cost. Got developers? Tallyfy's [Open API](/products/pro/integrations/open-api/) gives you full control. ::: ### Why use Tallyfy instead of automation-only tools? 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 bots - **Structured task management** - Work flows in a logical order with clear ownership - **Cross-app [integration](/products/pro/integrations/)** - Human decisions trigger automated actions across your stack ### Key integration use cases Here are patterns that work well with the Tallyfy Zapier connector: #### 1. CRM-triggered onboarding A deal closes in your CRM - then what? Zapier fires a trigger, and Tallyfy's "Launch Process" action instantly starts your client onboarding [process](/products/pro/tracking-and-tasks/processes/). The right [members](/products/pro/documenting/members/) get tasks assigned automatically, and everyone sees progress without "what's the status?" emails. #### 2. Scheduled process launches Weekly reports? Monthly audits? Zapier's schedule trigger pairs with Tallyfy's "Launch Process" action to [launch](/products/pro/launching/) your [processes](/products/pro/tracking-and-tasks/processes/) on a recurring schedule. You won't miss one again. #### 3. Communication-based task creation Stop losing requests in email and Slack. An email to support@yourcompany.com can become a standalone [task](/products/pro/tracking-and-tasks/tasks/) in Tallyfy. A Slack keyword can kick off an entire [process](/products/pro/tracking-and-tasks/processes/). Nothing falls through the cracks. #### 4. Web form tracking Customer fills out a web form - then what? Form data flows into Tallyfy, the right [process](/products/pro/tracking-and-tasks/processes/) [launches](/products/pro/launching/) based on request type, and you track everything from "submitted" to "done." ### Get started - [Connect your Tallyfy account to Zapier](/products/pro/integrations/middleware/zapier/how-to-connect-your-tallyfy-account-to-zapier/) - [Launch a Tallyfy process with Zapier](/products/pro/integrations/middleware/zapier/how-to-customize-your-tallyfy-zap-for-launch-process/) - step-by-step guide - **[Automate monthly process launch with Zapier](https://tallyfy.com/products/pro/integrations/middleware/zapier/how-to-automate-monthly-process-launch-with-zapier/)**: Tallyfy integrates with Zapier's schedule trigger to automatically launch recurring monthly processes like reports or reviews. Set a date and time, link it to a template, and you're done in about five minutes. ## Automate monthly process launches with Zapier Tallyfy can automatically [launch processes](/products/pro/launching/) every month through Zapier's schedule trigger. It takes about 5 minutes to set up, and you won't have to remember to kick off monthly reporting, reviews, or any other recurring workflow again. :::note[Why consider alternative integration platforms?] Zapier handles basic connections well, but for business-critical integrations we'd recommend [middleware](/products/pro/integrations/middleware/) platforms like **n8n**, **Make**, or **Microsoft Power Automate** - they're more capable and cost-effective. If you've got developers, Tallyfy's [Open API](/products/pro/integrations/open-api/) lets you build custom integrations directly. ::: - **[Automate tasks using Zapier](https://tallyfy.com/products/pro/integrations/middleware/zapier/how-to-automate-tasks-in-tallyfy-using-zaps/)**: Zapier can automatically mark Tallyfy tasks as complete when triggered by external events. Use a known task ID directly, or first search for the task through a template ID and process name before passing it to the Complete Task action. ## Automate task completion with Zaps Zapier can automatically complete [tasks](/products/pro/tracking-and-tasks/tasks/) in Tallyfy when something happens in another app. This same approach works with other [middleware](/products/pro/integrations/middleware/) platforms like Power Automate. ## How the flow works [Diagram removed for brevity] Two things to note: - If you don't already have the task ID, you'll need to find it first using a template ID plus either the process name or a kick-off field value - Both paths end at the same "Complete Task" action that marks the task done through Tallyfy's API :::note[Considering integration alternatives] Zapier works for simple connections, but we'd generally recommend [middleware](/products/pro/integrations/middleware/) platforms like **n8n**, **Make**, or **Microsoft Power Automate** for more serious integrations - they're more capable and cost-effective. For full control, consider Tallyfy's [Open API](/products/pro/integrations/open-api/) to build custom integrations directly. ::: Start by picking a trigger that can send custom data like a process name. If you already have the [task](/products/pro/tracking-and-tasks/tasks/) ID, skip ahead to completing the task. Otherwise, find it first: Once you've found the [process](/products/pro/tracking-and-tasks/processes/), here's how to complete the [task](/products/pro/tracking-and-tasks/tasks/): Here's a video walkthrough showing the full setup: Keep in mind, if you test a zap that completes a [task](/products/pro/tracking-and-tasks/tasks/), you'll need to manually re-open that task in Tallyfy before you can test again. - **[Connect Tallyfy to Zapier](https://tallyfy.com/products/pro/integrations/middleware/zapier/how-to-connect-your-tallyfy-account-to-zapier/)**: Connecting Tallyfy to Zapier takes about 5 minutes using OAuth2 authorization. Find your Organization ID in Tallyfy settings, then search for Tallyfy in Zapier to sign in securely without sharing credentials. ## Connect your Tallyfy account to Zapier Tallyfy connects to Zapier through OAuth2[^1] - you'll authorize the connection on Tallyfy's own login page, so your credentials never pass through Zapier directly. The whole setup takes about 5 minutes. :::note[Considering integration alternatives] Zapier works for simple connections, but we'd generally recommend [middleware](/products/pro/integrations/middleware/) platforms like **n8n**, **Make**, or **Microsoft Power Automate** for more capable, cost-effective integrations. If you've got development resources, Tallyfy's [Open API](/products/pro/integrations/open-api/) gives you full control - you can even use AI to generate code for serverless functions. ::: ### Requirements - An active Tallyfy account - A Zapier account (free or paid) - Your Tallyfy **[Organization ID](/products/pro/miscellaneous/how-to-find-your-tallyfy-ids/)** ### Connection process #### Step 1 - Find your Tallyfy Organization ID #### Step 2 - Authorize in Zapier #### Step 3 - Verify the connection ### Troubleshooting Connection not working? Check these first: - Double-check that you copied the Organization ID correctly - Make sure you're using the right Tallyfy credentials on the login page - Confirm your Tallyfy account has access to the organization you're connecting - Still stuck? [Contact Tallyfy support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/) Once connected, you can start building Zaps that automate workflows between Tallyfy and your other apps. [^1]: Industry-standard protocol for secure third-party authorization without sharing passwords - **[Action to 'Launch Process'](https://tallyfy.com/products/pro/integrations/middleware/zapier/how-to-customize-your-tallyfy-zap-for-launch-process/)**: Zapier's "Launch Process" action automatically starts a Tallyfy process from any trigger event by mapping external data into kick-off form fields and assignees. Any values set in the Zap override template defaults. ## Setting up the Launch Process action in Zapier The Zapier "Launch Process" action lets you automatically [launch a Tallyfy process](/products/pro/launching/) whenever a trigger fires - like a Google Forms submission, a CRM deal closing, or a support ticket arriving. ### Example use cases - **CRM onboarding** - A new contact in Salesforce or HubSpot triggers a Tallyfy onboarding process with client data pre-filled. - **Sales-to-delivery handoff** - A deal marked "Closed Won" launches an implementation process, passing client details and timeline straight through. - **Support escalation** - A high-priority ticket spins up an incident response process with the right people assigned. :::note[Consider other middleware options] Zapier works for simple connections, but we generally recommend [middleware](/products/pro/integrations/middleware/) like **n8n**, **Make**, or **Microsoft Power Automate** for more capable, cost-effective integrations. If you've got development resources, Tallyfy's [Open API](/products/pro/integrations/open-api/) gives you full control. ::: :::note[Zapier date format] Zapier doesn't support natural language dates like `2 days`, `2d`, or `5 weeks`. A deadline modifier like `-2d` appended to a date will throw an error - you need to pass actual date values. ::: ### How Zap values interact with template defaults Any value you set in the Zap overrides the corresponding [template](/products/pro/documenting/templates/) setting - including assignees, deadlines, and [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) values. :::caution[Assignee behavior when fields are blank] **Deadlines and assignees behave differently when you don't fill them in:** - **Deadlines left blank** - the template's default deadline applies. - **Assignees left blank** - Tallyfy's middleware sends the request with `override_default_owners=true`, which means the API receives an empty assignee list. In practice, the API falls back to template assignees when the provided list is empty, but results can be unpredictable depending on template configuration. **What to do:** 1. **Set assignees explicitly** in your Zap for each step - this is the safest approach. 2. **Use automation rules** on your template to reassign tasks after launch if needed. 3. **Assign groups** - you can search for and assign Tallyfy groups directly in the Zap. ::: :::note[Passing checklist values] To fill out a checklist [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) when [launching a process](/products/pro/launching/) via Zapier, pass comma-separated values from your trigger source. The items you pass become the "checked" entries in the checklist. ::: - **[Zapier actions and triggers](https://tallyfy.com/products/pro/integrations/middleware/zapier/zapier-actions-and-triggers/)**: The Zapier integration for Tallyfy grew from a small set of actions to a full set covering users, tasks, processes, templates, form fields, comments, tags, folders, and search, plus four polling triggers and five instant (webhook) triggers, and it authenticates with OAuth 2.0. ## What the Zapier integration now covers Tallyfy's Zapier integration was expanded from a small set of actions to a full set that mirrors what Tallyfy's other connectors do. You can now build Zaps for the same core actions across ten categories, plus polling and instant (webhook) triggers. :::note[Live in the Zapier app] The expanded actions and triggers are live in the current published Tallyfy app on Zapier (version 1.6.1). When you add the Tallyfy app to a Zap, you'll see the full set of actions, the four polling triggers, and the five instant (webhook) triggers. ::: ### Actions by category | Category | What you can do | |---|---| | **Users and guests** | Invite members, read and list users, change roles, enable or disable accounts, create and update guests | | **Groups** | Create, read, update, and delete groups | | **Tasks** | Create standalone tasks, complete, update, reopen, and read tasks; change assignees, deadlines, and form field values; list your tasks or a process's tasks | | **Processes** | Launch a process from a template, read, update, archive, reactivate, and list processes; submit or reopen kick-off forms | | **Templates** | Read, list, create, clone, update, and delete templates; list template steps; manage kick-off form fields | | **Form fields** | Add, update, move, and delete step form fields; add, update, reorder, and delete kick-off fields; update dropdown options | | **Comments and issues** | Add comments, edit or delete them, report an issue on a task, and resolve an issue | | **Tags** | Create, update, and delete tags; tag or untag templates and processes | | **Folders** | Create, update, and delete folders; move templates and processes in and out | | **Search** | Keyword search across tasks, processes, and templates, one type at a time or all at once, plus a finder that looks up any record's ID | In total the integration now ships 80 actions (52 that create or change things plus 28 that find or read things) and the four triggers, up from 16 actions before, backed by 13 hidden lookups that fill dropdowns like templates, users, and tasks. :::note[Not yet included] Automation rules, step-level template edits (adding, cloning, reordering, or reassigning individual steps), and a raw API passthrough are a later follow-up. For those, use Webhooks by Zapier to call Tallyfy's [Open API](/products/pro/integrations/open-api/) directly. ::: ### Triggers (polling) Zapier went from zero working triggers to four. Each trigger polls: it checks Tallyfy on a schedule, picks up new items, and de-duplicates by record id so nothing repeats. 1. **New process launched** - a process starts, optionally scoped to one template. 2. **Task completed** - a task is marked complete. 3. **Task assigned to you (new task)** - a new task lands in your queue. 4. **Comment or issue added** - a comment or reported issue appears on a task you choose to watch. Zapier sets the polling schedule from your Zapier plan, so there's no interval to configure. Plans with faster polling pick up new items sooner. ### Triggers (instant, webhook-based) Five newer triggers skip the polling wait. Tallyfy pushes the event to your Zap the moment it happens, so the Zap starts in real time. Each carries an **(Instant)** label in the trigger picker: 1. **New Process Launched (Instant)** - fires the moment a process is launched from a template. 2. **Process Completed (Instant)** - fires the moment a whole process reaches completed status. 3. **New Task Assigned (Instant)** - fires the moment a task is assigned to someone. 4. **Task Completed (Instant)** - fires the moment a task is marked complete. 5. **New Comment or Issue on a Task (Instant)** - fires when a comment is added, or an issue is raised or resolved, on a task. **Process Completed is instant-only.** There is no polling version of it, so when you need to react to a whole process finishing, this instant trigger is the one to use. :::note[Instant triggers need an admin connection, and the backend is rolling out] Turning on an instant trigger registers an organization-wide webhook, which only an organization admin can do. Connect as a non-admin and you'll get a permission error, so use the matching polling trigger instead. The delivery backend is also still rolling out across Tallyfy organizations. Until yours has it, an instant trigger may not fire, so keep a polling trigger as your fallback and switch over once instant delivery is live for your organization. ::: ### Authentication (OAuth 2.0) Zapier connects to Tallyfy with OAuth 2.0. When you add your Tallyfy account in Zapier, you enter your [Organization ID](/products/pro/miscellaneous/how-to-find-your-tallyfy-ids/), then sign in to Tallyfy and approve access. There's no API token to copy, and access refreshes automatically in the background. The connection acts on behalf of the user who signs in, so connect an account with the right permissions for what your Zaps do. ### Getting started 1. Create a Zap in Zapier, or open one you already have. 2. Add the Tallyfy app and connect your account: enter your Organization ID, sign in, and approve access. 3. Pick an action, for example Launch Process, and map the input fields. You'll see your real templates, users, and tasks in the dropdowns. 4. To react to Tallyfy events, start the Zap with one of the four triggers. 5. Test with sample data, then turn the Zap on. Remember the API terminology: "templates" in the Tallyfy UI are "checklists" in the API, and "processes" are "runs". ## AI-native alternative (Tallyfy MCP) If building Zaps by hand is more than you need, the Tallyfy MCP server lets an AI assistant call these same actions in plain English. See the [MCP server](/products/pro/integrations/mcp-server/) guide. - **[Zapier integration troubleshooting](https://tallyfy.com/products/pro/integrations/middleware/zapier/zapier-integration-troubleshooting/)**: Fix common Tallyfy-Zapier problems including OAuth2 authentication failures, webhook triggers that don't fire, and action errors from wrong template IDs or missing fields. Covers connection issues, field mapping, and error messages. ## Fix common Tallyfy-Zapier problems fast Most Tallyfy-Zapier issues fall into three buckets: authentication failures, triggers that don't fire, or actions that error out. Here's how to fix each one. :::caution[Tallyfy uses webhooks, not polling] Tallyfy's Zapier connector fires webhook-based triggers instantly when events happen -- there's no 5-15 minute polling delay. This means triggers like "Task Completed" and "Process Started" should fire within seconds. If they don't, the problem is usually a configuration issue, not a timing one. ::: ### Connection and authentication issues Tallyfy connects to Zapier through OAuth2. You'll authorize with your Tallyfy credentials, and the connector stores an `access_token`, `refresh_token`, and your `organization_id`. Token refresh is automatic -- you shouldn't need to reconnect often. **If your connection fails:** - **"Authentication failed"** -- Reconnect your Tallyfy account in Zapier. Go to **My Apps** > **Tallyfy** > **Reconnect** - **Can't find Tallyfy in Zapier** -- Search for "Tallyfy" in the Zapier app directory, or go directly to [zapier.com/apps/tallyfy](https://zapier.com/apps/tallyfy) - **"Invalid client" error** -- Your OAuth credentials are misconfigured. Disconnect and re-authorize through Zapier's connection flow. The OAuth token URL is `https://account.tallyfy.com/oauth/token` - **Permission denied** -- Make sure your Tallyfy account has Admin or Standard member permissions. Light users and Guests can't authorize integrations ### Trigger problems Tallyfy's Zapier connector includes two instant (webhook) triggers and several polling-based data triggers: #### "Task Completed" trigger not firing - Confirm the task was actually completed in Tallyfy, not just reopened or skipped - Check that your Zap is turned **On** in Zapier's dashboard - Verify the connected Tallyfy account has access to the organization where the task lives #### "Process Started" trigger not firing - Confirm the process actually launched successfully in Tallyfy - Check if the template was modified after you set up the Zap -- template changes can break field mappings - Make sure the connected account can see the process ### Action errors The connector supports actions like launching processes, completing tasks, adding comments, changing assignees, and changing deadlines. #### "Start Process" action failing - **Template ID wrong** -- Copy the template ID directly from Tallyfy. If you renamed or duplicated the template, the old ID won't work - **Missing kick-off form fields** -- If your template has required kick-off form fields, you must map values for every required field - **Date formatting** -- Tallyfy expects UTC timestamps. If you're passing dates from another app, make sure they're formatted correctly #### "Standalone Task" or "Process Task Complete" action failing - **Assignee doesn't exist** -- The email address must belong to a member or guest in your Tallyfy organization - **Guest-only assignments** -- Tallyfy won't let you assign a task exclusively to guests. If all assignees are guests, the connector automatically adds the connected user as a co-assignee - **Required form fields empty** -- If the task has required form fields, fill them before completing it ### Field mapping tips Bad field names in Tallyfy cause confusing dropdowns in Zapier. Name your fields specifically: | Bad name | Better name | |----------|-------------| | Notes | Customer_Requirements_Notes | | Comments | Customer_Service_Comments | | Date | Contract_Start_Date | | Address | Billing_Address | | Name | Client_Name | Avoid special characters in field names -- stick to letters, numbers, and `_`. If a field name appears in multiple steps, use identical names so Zapier can map them consistently. ### Common error messages | Error message | Cause | Fix | |---------------|-------|-----| | "Authentication failed" | Expired or invalid OAuth token | Reconnect your Tallyfy account in Zapier | | "Invalid client" | OAuth misconfiguration | Disconnect and re-authorize through Zapier | | "Template not found" | Wrong template ID or deleted template | Copy the correct ID from Tallyfy | | "User not found" | Invalid assignee email | Verify the email belongs to an org member or guest | | "Access denied" | Insufficient account permissions | Use an Admin or Standard member account | | "Invalid field value" | Wrong data type or format | Check that dates, numbers, and text match expected formats | ### Debugging steps 1. **Test each Zap step** -- Use Zapier's built-in test feature to run each step individually and inspect the output 2. **Check Zap history** -- Go to your Zap's history tab to see detailed execution logs, including error responses from Tallyfy's API 3. **Verify in Tallyfy** -- Check the task or process directly in Tallyfy to confirm it's in the expected state ### Getting help If these steps don't resolve your issue: 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 your Zap's error logs and screenshots ### Robotics - **[Boston Dynamics integration](https://tallyfy.com/products/pro/integrations/robotics/boston-dynamics/)**: Boston Dynamics Spot robots handle industrial inspections across 1,500+ deployments but lack cross-site knowledge sharing and conditional mission logic. A workflow platform could fill those gaps through Orbit's REST API and webhooks. :::note[Information currency] This article discusses potential integration scenarios between Boston Dynamics Spot robots and workflow management platforms. These approaches are conceptual and aren't currently implemented. For current Boston Dynamics capabilities, see their [official documentation](https://dev.bostondynamics.com/)[1]. ::: ## Spot robots and workflow management gaps Boston Dynamics Spot is deployed in over 1,500 locations worldwide, mostly for industrial inspection and monitoring. The robot uses Orbit fleet management software for mission recording and data collection. This article covers workflow gaps and potential integration approaches. ## What Boston Dynamics provides today **Hardware:** - **Spot robot**: Starting at roughly $75,000 for the base Explorer Kit (total cost often exceeds $100,000 with attachments) - **Battery life**: About 90 minutes per charge - **Payload capacity**: 14kg - **Mobility**: 1.6 m/s top speed, climbs stairs, handles rough terrain - **Temperature range**: Operates up to 55C **Software:** - **Orbit**: Fleet management, data collection, and AI-powered analysis (formerly Scout) - **AI visual inspections**: Detects anomalies like debris, spills, or corrosion automatically - **Site View**: Creates digital twins from 360-degree images for remote monitoring - **Spot SDK**: Python and C++ APIs for custom development - **Autowalk**: Record missions by walking routes, then replay them autonomously - **API and webhooks**: Connect to third-party enterprise systems **Deployment scale:** - Over 1,500 Spot robots deployed worldwide - Millions of automated data captures performed - Active in over 35 countries ## Workflow gaps in current Spot deployments ### Static mission recordings Spot missions work by recording paths and actions, then playing them back. From Boston Dynamics' SDK docs, missions follow a "go here, do this" pattern - a linear series of actions at defined locations. What's missing: - Missions play back identically each time - no conditional logic based on findings - Facility layout changes require re-recording missions - Each mission is a separate file to maintain ### No cross-site knowledge sharing Each Spot deployment runs independently. Inspection improvements at one facility don't transfer to others, mission files aren't shared between sites, and each deployment recreates similar missions from scratch. There's no centralized procedure repository. ### Weak procedure documentation Orbit tracks mission execution and collects sensor data, timestamps, robot paths, and images. It also provides basic AI anomaly detection. But it doesn't capture procedural context for why actions were taken, doesn't version-control inspection procedures, and doesn't produce standardized compliance reporting across facilities. ## How Spot missions work ### Autowalk mission structure Spot uses Autowalk for autonomous navigation. An operator drives Spot through a facility using a controller while the robot records waypoints and navigation data. This creates a `.walk` file with a linear series of actions - "go to location A, perform action 1, go to location B, perform action 2." During playback, the robot follows recorded waypoints autonomously with basic obstacle avoidance. If the environment changes significantly, the mission may fail and need re-recording. At scale, organizations manage dozens or hundreds of mission files per facility. Layout changes require updating affected missions, and there's no built-in system for sharing procedures across sites. ## Potential workflow integration approach A workflow platform could complement Orbit by adding a procedure layer: - Centralized inspection procedure repository with version control - Cross-facility procedure sharing - Compliance documentation templates Integration would happen through Orbit's API for mission status and data, webhook notifications when missions complete, custom mission actions calling external APIs, and post-mission workflow triggers. [Diagram removed for brevity] **What to notice:** - Orbit handles robot operations and data collection - The workflow platform manages procedures and compliance - Integration happens through APIs and webhooks ## Real-world Spot deployments **Industrial inspection:** - National Grid uses Spot at substations, including high-voltage facilities where people can't enter during operation - AB InBev deployed Spot in their Leuven brewery as part of their "Brewery of the Future" program - Purina integrates Spot into predictive maintenance workflows **Hazardous environments:** - UKAEA deployed Spot at Chernobyl with a radiation detection payload - Nuclear facilities use Spot in areas with radiation or other hazards - Chemical plants deploy Spot for dangerous area monitoring **At scale:** - Spots have automated over 1 million data captures - Fleet takes a tumble roughly once every 50 kilometers - Used for acoustic leak detection, vibration monitoring, and thermal inspections ## 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 connect to external systems - Developer docs available at dev.bostondynamics.com[2] - **[Apptronik Apollo integration](https://tallyfy.com/products/pro/integrations/robotics/apptronik/)**: Tallyfy can work as a workflow management layer for Apptronik's Apollo humanoid robots, connecting through a ROS bridge to fill gaps in fleet coordination, procedure updates, and compliance documentation. :::note[Information currency] Apollo is in pilot deployment with commercial scaling planned. Capabilities and partnerships continue to evolve. Verify current status at [apptronik.com](https://apptronik.com/apollo). ::: ## How Tallyfy could work with Apollo robots Apptronik's Apollo is a humanoid robot built for industrial use, standing 5'8" tall and able to lift 55 pounds. It's currently being tested in pilot programs with Mercedes-Benz and GXO Logistics. Google's Gemini integration gives Apollo AI capabilities, but it doesn't have dynamic workflow management for enterprise-scale deployments. That's where Tallyfy fits in. ## Apollo hardware and software ### Hardware specs - **Height**: 1.73 meters (5'8") - **Weight**: 72.6 kg (160 lbs) - **Payload**: 25 kg (55 lbs) - **Battery**: Hot-swappable packs, 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 - **AI integration**: Google Gemini (vision-language-action model) ### Current deployments Apptronik has announced pilot programs with these companies: - **Mercedes-Benz**: Automotive manufacturing facilities (pilot phase) - **GXO Logistics**: Warehouse operations proof-of-concept (pilot phase) - **Jabil**: Manufacturing partnership for electronics production All deployments remain in pilot phase, with commercial scaling planned as the technology matures. ## Workflow gaps Tallyfy could fill ### Static task programming Apollo robots run pre-programmed tasks configured through their control interface. When they hit a scenario outside programmed parameters, they stop and wait for manual updates. **Example**: An Apollo sorting packages encounters a new product category. Without handling parameters for it, the robot stops and waits for an operator to update its configuration. **With Tallyfy**: Apollo could query Tallyfy's REST API for procedures on the fly, receiving handling instructions, weight limits, and destination zones without stopping operations. ### Individual robot configuration Each Apollo operates with its own task configuration. When one robot discovers a better approach, that knowledge doesn't automatically spread to other units in the fleet. Updates require manual configuration of each robot. **With Tallyfy**: Centralize all procedures in Tallyfy so every robot accesses the same knowledge base. Update once, and it propagates across the fleet automatically. ### 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. **With Tallyfy**: Launch validated processes in Tallyfy that document each step with parameters, creating automatic audit trails for compliance. ## How Apollo currently works Apollo uses a point-and-click interface for task programming. This simplifies configuration compared to traditional industrial robots, but tasks still need parameter setup for each application. Google's Gemini integration handles perception and planning, identifying objects and planning movements. But business rules and procedures have to be defined separately. With multiple Apollo robots, organizations need to manage task configurations across units, handle procedure updates, track performance, and maintain compliance documentation. As deployments scale, centralized procedure management becomes important for consistency across the fleet. ## Integration architecture ### How the pieces connect [Diagram removed for brevity] **What to notice:** - A ROS bridge connects Apollo's control system to Tallyfy's API - The 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 approach The integration would use a ROS bridge to connect Apollo's control system with Tallyfy's REST API. Here's what that looks like in practice: **ROS integration layer** - A ROS package that subscribes to Apollo task requests, queries Tallyfy for procedure steps, translates them into ROS action sequences, and reports completion status back. **Procedure management** - Store standard operating procedures as Tallyfy templates. Launch processes when Apollo begins tasks. Track step completion with timestamps and parameters. **Fleet coordination** - A central procedure repository that all robots access. Updates propagate automatically. It aggregates performance data across the fleet and generates compliance documentation along the way. ## Where this applies ### Manufacturing Apollo robots in manufacturing could pull centralized work instructions from Tallyfy, maintain version-controlled procedures for quality management, and automatically document all tasks performed - particularly useful for regulated industries. ### Warehouse operations In logistics, Tallyfy integration could provide dynamic routing based on current conditions, standardized handling procedures across the robot fleet, and real-time visibility into task progress. ### Regulated industries For pharmaceutical or food production, the integration offers version-controlled validated procedures, complete audit trails, deviation tracking, and batch record generation with all parameters documented. ## What each platform brings **Apollo handles**: Physical task execution, object recognition, safe human collaboration, and mobile manipulation. **Tallyfy handles**: Centralized procedure management, audit trails and compliance documentation, process coordination across multiple robots, and business rule enforcement. Organizations deploying Apollo with Tallyfy could expect reduced time managing robot configurations, consistent procedures across the fleet, automatic compliance documentation, and faster adaptation to procedure changes. ## Getting started 1. **Assessment** - Document current robot task configurations and workflows 2. **Planning** - Identify procedures suitable for centralized management 3. **Pilot** - Test integration with a limited deployment before scaling 4. **Documentation** - Create procedure templates in Tallyfy 5. **Training** - Make sure operators understand the integrated system 6. **Scaling** - Expand based on pilot results You'll also need Apollo robots with ROS access, network connectivity for API communication, a Tallyfy organization with API access, and a testing environment. ## Apollo commercial status Apptronik has raised significant funding (reported Series A over $350 million) to scale Apollo production. The company is demonstrating useful work with early customers, with full commercialization planned as the technology proves itself in pilot deployments. Tallyfy integration development would align with Apollo's commercial availability timeline. - **[KUKA Robotics integration](https://tallyfy.com/products/pro/integrations/robotics/kuka/)**: Tallyfy works as a workflow layer above KUKA's robot fleet, from 6kg collaborative arms to 1300kg heavy-duty systems. It provides SOP documentation, audit trails, and fleet-wide visibility that KUKA's native tools don't cover. :::note[Information currency] This article describes potential integration approaches between KUKA robots and Tallyfy. KUKA's software and capabilities change frequently - verify current specs and integration requirements with KUKA documentation before implementation. ::: ## KUKA robots and workflow management KUKA makes industrial robots ranging from 6kg collaborative models to 1300kg heavy-duty systems. Their motion control and programming tools are strong, but managing procedures and documentation across robot fleets typically requires a separate workflow system. ## KUKA robot families and software ### 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** - Mid-range 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 with a virtual robot controller for simulation. Supports AI-ready architecture with an optional NVIDIA expansion board, and it's compatible with existing KRL programs. **KUKA.WorkVisual** - Offline programming and configuration tool. Handles field bus setup, I/O mapping, and virtual commissioning. **SmartPAD 2.0** - Teach pendant for manual programming. Cable-connected for safety-rated operation. **KUKA Robot Language (KRL)** - Pascal-based programming language tuned for KUKA hardware. Each program consists of paired .src (movement commands) and .dat (position data) files. ## How KUKA programs are deployed KUKA robots run programs written in KRL. Each program needs two files with identical names: - `.src` file - Movement commands and logic - `.dat` file - Position data and variables You can load programs onto controllers in a few ways: 1. **USB transfer** - Copy to a USB drive and load through the controller interface 2. **Network deployment** - Transfer via Ethernet using KUKA.WorkVisual 3. **Teach pendant** - Program directly on the smartPAD device Each controller stores programs locally in the KRC/R1/Programs directory. ### Programming methods **Teach pendant** - Manually guide the robot through positions. Time-intensive but doesn't require external tools. **Offline programming** - Create and test programs in simulation first. KUKA.Sim handles 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** - The KUKA.PythonCore module lets you write Python alongside traditional KRL. ## Available integration protocols 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 gaps in multi-robot deployments When you're managing multiple KUKA robots, these operational challenges come up often: **Program version control** - Each robot may run a different version of the same program, making standardization difficult. **Procedure documentation** - Robot execution data (coordinates, timestamps) doesn't automatically link to SOPs or work instructions. **Knowledge sharing** - Improvements found on one robot require manual propagation to other units. **Audit trails** - Connecting robot actions to compliance and quality documentation requires separate systems. **Fleet-wide updates** - Changing procedures across a robot fleet means updating programs on each controller one by one. ## Potential Tallyfy integration approach Tallyfy could work as a workflow layer above KUKA's motion control system, handling documentation and procedure management that KUKA's tools don't cover. ### 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 runs and when. **Audit trails** - Keep compliance records connecting robot actions to quality requirements. **Fleet visibility** - A dashboard showing all robots and their current process status. **Knowledge base** - Central repository for procedures, accessible across all robots. ### Integration requirements - KUKA robots with KRC2, KRC4, or KRC5 controllers - Ethernet network connectivity - OPC UA or KUKA.Connect for data exchange - Middleware to translate between KUKA protocols and the Tallyfy API - Tallyfy organization with API access enabled ## Implementation considerations ### Assessment phase Before you start: 1. Document current KRL programs and their associated procedures 2. Identify which processes need audit trails or compliance tracking 3. Check your network infrastructure for robot connectivity 4. Map integration points between KUKA controllers and external systems ### Integration options **Read-only monitoring** - Track robot status and link to Tallyfy processes without modifying robot programs. Lowest complexity. **Bidirectional integration** - The robot reports completion status while Tallyfy provides procedure parameters. Requires middleware development. **Full workflow control** - Tallyfy initiates robot programs based on process triggers. Most complex - needs extensive testing. - **[Unitree Robotics integration](https://tallyfy.com/products/pro/integrations/robotics/unitree/)**: Unitree Robotics builds quadruped and humanoid robots with strong SDKs for movement control but lacks workflow management for fleet coordination. Tallyfy could serve as a centralized process layer that delivers procedures and logs task completions across a robot fleet. :::note[Information currency] This article covers potential integration between Unitree Robotics and Tallyfy. Specs and pricing may change - check Unitree's official site for current details. No official integration exists yet. ::: ## Unitree Robotics and workflow gaps Unitree Robotics builds quadruped and humanoid robots with SDKs for movement control. Their hardware covers inspection, security, and research. But like most robotics platforms, they focus on hardware control - not operational workflow management. That's where Tallyfy could fit in. ## Robot platforms **Quadruped robots:** - **Go2**: Consumer quadruped with AI vision (Air, Pro, and Edu variants) - **B2**: Industrial quadruped for inspection and security - **A2**: Industrial model, 100kg load capacity, 20km range - **B2-W**: Hybrid wheeled and walking modes **Humanoid robots:** - **G1 Basic**: Entry-level, remote-controlled home use - **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**: Research-focused humanoid ## Software and SDKs **Development SDKs:** - **unitree_sdk2**: C++ SDK for Go2, B2, H1, G1 using CycloneDDS - **unitree_sdk2_python**: Python interface - **unitree_legged_sdk**: SDK for Aliengo, A1, Go1, B1 models - **ROS/ROS2**: Native robotics middleware support - **Simulation**: MuJoCo and Isaac Lab for virtual testing **Control features:** - Low-level motor control and custom gait development - UDP and DDS communication protocols - SLAM for mapping and autonomous navigation - Computer vision with NVIDIA Jetson (EDU models) ## Where these robots get used **Industrial inspection:** - Thermal power plants for equipment monitoring - Petrochemical plants in hazardous zones - Power grid substations - Brewery operations for routine checks **Logistics and warehousing:** - Material handling and transport - Inventory monitoring - Warehouse security patrols **Agriculture:** - Seedling monitoring - Terrain assessment and mapping **Research:** - Academic programs - Carnegie Mellon SoFTA project (stable manipulation while walking) - Caltech/UT Austin SHIELD safety framework testing **Healthcare and service (emerging):** - Supply delivery assistance - Patient monitoring support ## What's missing: workflow management Here's where Unitree's platform falls short for operational use. **Procedure programming:** Robots run hardcoded Python or C++ scripts deployed individually via SSH. When procedures change, engineers must update code, test in simulation, and redeploy to each unit. That's slow. **Knowledge sharing:** There's no built-in way to share learnings across a fleet. If one robot discovers a better approach, it stays isolated unless someone manually codes and deploys the fix to every other unit. **Operational tracking:** Unitree provides telemetry (battery, location, sensors) but not process-level tracking. There's no native way to log which procedures ran, when tasks finished, or maintain audit trails. **Multi-robot coordination:** Each robot runs its own code version independently. Nothing manages what procedures are deployed where or keeps fleets consistent. ## How Tallyfy could fill these gaps **Dynamic procedures:** Instead of hardcoded scripts, robots could query Tallyfy's API for current procedures. When inspection methods change, updates reach all robots without redeployment. **Shared knowledge base:** Robots could pull standardized operating procedures from Tallyfy templates. Document a new equipment type once, and it's available fleet-wide. **Process tracking and audit trails:** Robots could launch Tallyfy processes and mark tasks complete with sensor data, photos, and timestamps - creating compliance records automatically. **Fleet-wide updates:** Changes to SOPs update centrally rather than requiring individual code deployment to each robot. ## Possible integration architecture A connector between unitree_sdk2 and Tallyfy's API could work like this: [Diagram removed for brevity] **What to notice:** - The connector bridges unitree_sdk2 and Tallyfy's REST API - Procedures live centrally, not in robot code - Every operation gets logged for compliance **Conceptual code example:** ```python # Hypothetical connector - no official integration exists 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']: sensor_data = robot.collect_data(step['location']) requests.post( f"https://api.tallyfy.com/tasks/{step['id']}/complete", headers={"Authorization": f"Bearer {api_key}"}, json={"sensor_data": sensor_data} ) ``` ## Example use cases **Site-specific inspections:** Robots fetch the right inspection procedure from Tallyfy for each site. When equipment types change, procedures update centrally - no robot code changes needed. **Warehouse fleet coordination:** Multiple robots reference the same Tallyfy procedures for patrol routes, inventory checks, or security protocols. One update reaches every robot. **Research reproducibility:** Academic labs could share experimental protocols through Tallyfy templates. Each robot runs identical procedures with automatic data logging. **Regulated industries:** In pharmaceutical, food safety, or other regulated operations, robots could log every procedure step, timestamp, and sensor reading in Tallyfy for regulatory review. ## What you'd need **On the Unitree side:** - Compatible models: Go2, B2, A2, G1, H1 - Network connectivity (WiFi or cellular) - Python environment for connector code - unitree_sdk2 or unitree_sdk2_python installed **On the Tallyfy side:** - Organization account with API access - Templates set up for robot procedures - API credentials **Technical factors to consider:** - You'll need to build custom connector middleware - Network latency matters for real-time API calls - Robots need fallback behavior when connectivity drops - Data formatting between SDK output and Tallyfy's API - **[Universal Robots integration](https://tallyfy.com/products/pro/integrations/robotics/universal-robots/)**: Universal Robots cobots use PolyScope X for visual programming but store programs locally on each controller. This creates problems for fleet-wide version management, knowledge sharing, and compliance audit trails. :::note[Integration status] This article describes a **conceptual integration** between Universal Robots and Tallyfy. The Tallyfy URCap referenced here doesn't currently exist as a commercial product. Information about Universal Robots capabilities is based on publicly available documentation. ::: ## What Universal Robots offers today - and where it falls short Universal Robots makes collaborative robots (cobots) used in manufacturing facilities worldwide. Their PolyScope X software handles programming, and URCaps allow hardware integration. But the platform relies on static programming that creates real challenges for managing workflows across robot fleets. ## Current hardware and software lineup ### Hardware platforms - **UR3e**: 3kg payload for precision assembly - **UR7e**: 7kg payload for light assembly and pick-and-place (renamed from UR5e) - **UR12e**: 12.5kg payload for palletizing and machine tending (renamed from UR10e) - **UR15**: 15kg payload, fastest cobot in the lineup - launched 2025 - **UR16e**: 16kg payload for heavy material handling - **UR20**: 20kg payload with 1750mm reach for large parts - **UR30**: 30kg payload with 1300mm reach for heavy industrial applications ### Software - **PolyScope X**: Latest platform with progressive disclosure UI, available in 22 languages, works from any browser. Supports modular programming with reusable functions, Smart Skills for positioning, Teach Mode for recording paths, and OptiMove for speed tuning - **PolyScope 5**: Still supported on existing e-Series deployments - **URCaps**: Plugin system 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 PolyScope X supports visual programming with a Program Tree interface, URScript for custom control, nested functions, multi-copy/paste of nodes, and an Operator Screen for simplified changeover management. It also includes newer program nodes like Halt, Timer, Process move, Circular move, Direction until, and Switch case - plus world-centric and tool-centric coordinate frames. ## Where static programming breaks down ### No dynamic knowledge lookup UR cobots run pre-programmed routines stored locally on each controller. Programs are static files. They can't query external procedures. Changes require manual reprogramming. Each robot keeps its own isolated program library. **What this looks like in practice**: A UR12e performing quality inspection encounters a new product variant. The robot has no program for this variant and stops production. An engineer has to create a new program, test it in URSim, and deploy it to the robot. A workflow management layer could let robots query standardized procedures for different product variants - reducing the need to build individual programs for each one. ### No way to share improvements across robots Each cobot runs its own programs independently. When an operator discovers that a slight wrist rotation improves connector insertion on a UR7e in electronics assembly, that improvement stays locked in that single robot's program. Nobody else benefits unless someone manually copies it. Documenting these improvements in a centralized SOP management system like Tallyfy would make the knowledge accessible across every robot deployment. ### Limited compliance and traceability PolyScope logs robot movements but not procedural compliance. There's no record of which SOP version was followed, limited context for operator interventions, and no easy way to prove adherence to quality standards. **Why this matters**: A medical device manufacturer using UR16e robots for sterile packaging needs to show FDA auditors that validated procedures were followed for each batch. PolyScope shows robot logs - but can't demonstrate SOP compliance. Version-controlled SOPs with electronic documentation of process steps would create audit trails linking robot operations to validated procedures. ## How UR cobots actually work Despite marketing about "easy programming," here's the reality: **Programs are static .urp files on the controller**: ```python # 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 ``` PolyScope saves URP files in binary format. They're not editable without the teach pendant. Each robot stores programs locally with no central management. File naming conventions serve as primitive version control. **The visual programming is still rigid.** The teach pendant lets you create programs visually, but the output is still static URScript. Programs can't adapt to variations. IF statements are hardcoded logic, not intelligence. **There's no learning mechanism.** If a cobot discovers an optimal force for insertion, that stays on one robot. Process improvements need manual updates across every robot's program. No feedback loops exist from production back to programming. ### What actually happens in production **Scenario**: UR12e assembling products with a new component variant. What happens: 1. Robot reaches pick position for new component 2. Component is 2mm different height (not in program) 3. Robot either crashes into the component, grips air, or uses wrong force 4. Production stops while an engineer edits the program on the teach pendant, tests new positions (30-60 minutes), saves as "program_v2_new_component.urp," and manually copies to other robots via USB 5. Three robots are still running the old version a week later ### The tracking gap **What UR logs show you**: ```text 09:15:23 - movej complete 09:15:24 - digital_out_0 = TRUE 09:15:25 - wait 0.5 ``` **What compliance auditors actually need**: ```text 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 ``` You can see that a robot is running "program_42.urp" at line 47. You can't see "Robot completing step 3 of 8 in assembly process" or "SOP version 2.3 being followed." ### URCaps don't solve this URCaps are plugins for specific hardware (grippers, cameras). They still generate static URScript. There's no dynamic procedure management, no cross-robot communication. Each URCap is another thing to maintain on each robot individually. ### Scaling gets painful fast With 10 UR robots, you're doing weekly USB stick tours to update programs. With 50 robots, it's a full-time job managing program versions. Beyond 100 robots, version control becomes chaotic. **Known technical constraints from UR forums and documentation**: - [Program size limitations](https://forum.universal-robots.com/t/ur10e-are-there-program-size-limitations/17869)[1]: controllers struggle with programs over 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)[2]: limited controller memory affects complex applications - No built-in fleet management or central program repository in PolyScope ## Conceptual integration architecture [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 ### What an integration would involve **URCap plugin layer**: Custom URCap built with the Universal Robots SDK, including program nodes that query an external workflow system, installation nodes for configuration, and 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, plus real-time status updates. **Data synchronization**: Robot telemetry sent to the workflow system, task completion reporting, quality metrics and sensor data capture, and process step verification. ## Where this matters most ### High-mix manufacturing Organizations running multiple product variants hit the static programming wall hard. Each variant needs separate programs. Libraries grow large. Changes require updating every robot. Knowledge about optimal approaches stays trapped in 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. Deviations require documentation and investigation. ### Multi-site operations Companies with robot fleets across facilities run into version management problems. Process improvements at one site don't propagate automatically. Inconsistent practices develop across locations. ## What each system does well **PolyScope X handles**: Real-time motion control, safety monitoring, digital I/O and sensor integration, force/torque sensing, vision system integration via URCaps, local program execution, and teach pendant programming. **A workflow platform could handle**: Centralized procedure libraries, version control for SOPs, cross-site knowledge sharing, compliance audit trails, deviation documentation, human-robot task coordination, and fleet-wide performance analytics. ## Technical requirements for integration A theoretical integration would need: - 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 - A workflow management system with API capabilities Organizations interested in workflow management for robotics should assess their specific use cases and technical requirements before evaluating whether integration is feasible. ### Tallyfy desktop ai - **[Connect Claude to Tallyfy Desktop](https://tallyfy.com/products/pro/integrations/tallyfy-desktop-ai/connect-claude/)**: Install the Anthropic Claude CLI and sign into your Claude.ai subscription so Tallyfy Desktop can drive it. The Install Wizard handles the bash installer with explicit consent, or you can install manually from anthropic.com. :::note[Subscription, not API key] Claude in Tallyfy Desktop uses OAuth via your Claude.ai account (Pro, Max, Team, or Enterprise plan). The app never asks for an `ANTHROPIC_API_KEY` and won't accept one. If you don't have a Claude subscription, sign up at [claude.ai](https://claude.ai)[1] first. ::: ## What gets installed Tallyfy Desktop drives Claude through Anthropic's official `claude` command-line tool (Claude Code). On first launch, the desktop app checks whether `claude` is on your `PATH` and whether you've signed in. If either is missing, it offers to install or guide you. The install command per platform is baked into the desktop app source code: | Platform | Command | |---|---| | macOS | `curl -fsSL https://claude.ai/install.sh \| bash` | | Linux | `curl -fsSL https://claude.ai/install.sh \| bash` | | Windows | `powershell -Command "irm https://claude.ai/install.ps1 \| iex"` | Binaries land under `~/.local/bin/` on macOS and Linux, and under `%LOCALAPPDATA%\claude\bin\` on Windows. No `sudo` or admin rights are required. ## Prerequisites - A Tallyfy account (you'll sign in to Tallyfy Desktop first, before any AI tab works) - A Claude.ai subscription on Pro, Max, Team, or Enterprise plan - A modern web browser for the OAuth sign-in step (the desktop app opens it for you) ## Option A: Install Wizard (recommended) This is the path the desktop app guides you through. The wizard shows the exact command before it runs and asks for an explicit consent gesture. ## Option B: Manual install If you'd rather install Claude outside the desktop app, that works too. Tallyfy Desktop only checks whether `claude` is on `PATH`; it doesn't care how it got there. ## First chat Once Claude is connected: 1. Click the **Claude** tab. 2. The model picker in the top-right shows the default Claude model (Sonnet 5 in v2.0.0). 3. Type your message and press Enter. You'll see the streamed response appear chunk by chunk. 4. The chat header shows the cost and token usage on completion. Because the [Tallyfy MCP server](/products/pro/integrations/mcp-server/) is auto-injected, Claude already knows about your tasks, processes, templates, and team. Try: - "Show me all my open tasks" - "Find the customer onboarding template" - "Create a task to review next quarter's hiring plan, due Friday" That last one will trigger the [Task Intent Widget](/products/pro/integrations/tallyfy-desktop-ai/task-intent-widget/), which offers a one-click button to create the task in Tallyfy. ## Verifying the install yourself If something feels off, you can check the same things the desktop app checks: ```bash # Is the binary on PATH? which claude # Does it run? claude --version # Are you signed in? test -f ~/.claude/.credentials.json && echo "signed in" || echo "not signed in" ``` The desktop app caches the detection result for 60 minutes. Press **Cmd+Shift+R** (or **Ctrl+Shift+R** on Windows/Linux) inside the Claude tab to force a re-detection after an install or login. ## Troubleshooting ### "`claude` binary not found" after install The installer writes to `~/.local/bin/` (or `%LOCALAPPDATA%\claude\bin\` on Windows), which isn't always on the default `PATH`. Add it: - **macOS / Linux**: `echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.zshrc` (or `~/.bashrc`), then restart Tallyfy Desktop. - **Windows**: open System Properties, click Environment Variables, add `%LOCALAPPDATA%\claude\bin` to your user `Path`. Then press Cmd+Shift+R (Ctrl+Shift+R on Windows/Linux) inside the Claude tab to retry detection. ### OAuth browser window doesn't open Some browsers block popup windows from desktop apps. Quit the browser, reopen it, then click **Sign in with Claude** again. If it still doesn't open, run `claude login` directly in a terminal as a workaround. ### "Permission denied" on macOS If the install script can't write to `~/.local/bin/`, your shell might be sandboxed. Try running the install command directly in Terminal.app rather than via the wizard. If `chmod` errors appear, run `chmod +w ~/.local/bin/` and retry. ### Quota or rate-limit errors mid-chat Claude's per-account quota varies by plan. If you hit a quota wall, the streamed response stops and an error event appears in the chat. Wait a few minutes and retry, or upgrade your Claude.ai plan. Tallyfy Desktop doesn't add quota on top of Anthropic's; the limit is whatever your subscription says. ### The model picker is empty This usually means the OAuth token expired. Click the user menu in the desktop app, choose **Sign out of Claude**, then click **Sign in with Claude** again. ## What Claude can do that the others can't Claude is the most capable provider in Tallyfy Desktop v2.0.0: - **Tool use** - Claude can call MCP tools (Tallyfy's auto-injected MCP server) during the chat, not just at the end. You'll see `tool-use-start` and `tool-use-end` events stream in the chat. - **Thinking** - Claude streams its reasoning in a separate channel that's visible in the chat (collapsible). - **Cost reporting** - Claude reports the exact USD cost of each run on completion. - **Browser automation** - the `claude --chrome` flag drives a sandboxed Chrome instance for browser-bound workflows. The desktop repo is private, but its `docs/COMPUTER-USE-DEFERRED.md` covers what this can and can't do. Ask support if you need the detail. - **Attachments** - drag a file into the chat and Claude reads it (limited to text and images in v1). The other providers cover subsets of these. See the [overview](/products/pro/integrations/tallyfy-desktop-ai/) for the full capability matrix. - **[Connect Codex to Tallyfy Desktop](https://tallyfy.com/products/pro/integrations/tallyfy-desktop-ai/connect-codex/)**: Install the OpenAI Codex CLI via npm and sign into your ChatGPT subscription so Tallyfy Desktop can drive it. The Install Wizard handles npm with explicit consent, or you can install manually with `npm install -g @openai/codex`. :::note[Subscription, not API key] Codex in Tallyfy Desktop uses OAuth via your ChatGPT account. The app never asks for an `OPENAI_API_KEY` and won't accept one. You need a ChatGPT Plus, Pro, Team, Enterprise, or Edu subscription. If you don't have one, sign up at [chatgpt.com](https://chatgpt.com)[1] first. ::: ## What gets installed Tallyfy Desktop drives Codex through OpenAI's official `codex` command-line tool (the `@openai/codex` npm package). On first launch, the desktop app checks whether `codex` is on your `PATH` and whether you've signed in. If either is missing, it offers to install or guide you. The install command per platform is baked into the desktop app source code: | Platform | Command | |---|---| | macOS | `npm install -g @openai/codex` | | Linux | `npm install -g @openai/codex` | | Windows | `npm install -g @openai/codex` | The binary lands in your global npm prefix (typically `/opt/homebrew/bin/codex` on macOS-arm64 with Homebrew, or `/usr/local/bin/codex` with classic npm). You'll need Node.js 18+ already installed. ## Prerequisites - A Tallyfy account (you'll sign in to Tallyfy Desktop first) - A ChatGPT Plus, Pro, Team, Enterprise, or Edu subscription - Node.js 18 or higher with `npm` available on `PATH` - A modern web browser for the OAuth sign-in step ## Option A: Install Wizard (recommended) ## Option B: Manual install ## First chat Once Codex is connected: 1. Click the **Codex** tab. 2. The model picker shows the default (GPT-5.5 in v2.0.0). 3. Type your message and press Enter. Codex streams plain-text responses, so you'll see the text appear chunk by chunk. Codex doesn't support MCP in v1, so the [Tallyfy MCP server](/products/pro/integrations/mcp-server/) isn't auto-injected as a tool. Instead, the desktop app prepends a system prompt that gives Codex your Tallyfy context (your org name, your role, links to your active processes). You can still trigger the [Task Intent Widget](/products/pro/integrations/tallyfy-desktop-ai/task-intent-widget/) from Codex chats; the widget watches for intent in the text Codex generates. ## Verifying the install yourself ```bash # Is the binary on PATH? which codex # Does it run? codex --version # Are you signed in? test -f ~/.codex/auth.json && echo "signed in" || echo "not signed in" ``` The desktop app caches detection for 60 minutes. Cmd+Shift+R (Ctrl+Shift+R on Windows/Linux) inside the Codex tab forces a re-detection. ## Troubleshooting ### `npm install` fails with EACCES Your npm prefix is system-owned. The two clean fixes are: 1. **Switch to a user-owned prefix** (recommended): see [npm's official fix](https://docs.npmjs.com/resolving-eacces-permissions-errors-when-installing-packages-globally)[3]. After reconfiguring, re-run the wizard. 2. **Use nvm** to manage Node.js: nvm puts npm in your home directory, sidestepping the issue. Install nvm from [nvm-sh/nvm](https://github.com/nvm-sh/nvm)[4], then reinstall Node.js via `nvm install 20`. Don't run the wizard with `sudo`; the desktop app won't do that for you and it creates permission problems later. ### "HTTP 401 Unauthorized" in the chat You haven't run `codex login` yet, or the OAuth token expired. From a terminal: ```bash codex login ``` Approve in the browser. Then go back to Tallyfy Desktop and press Cmd+Shift+R in the Codex tab to refresh detection. ### Codex hangs and produces no output This is the classic stdin issue. Codex's CLI treats open stdin as input to append to the prompt; without proper stdin redirection it can wait forever. Tallyfy Desktop closes stdin correctly when it spawns Codex, so you shouldn't hit this from inside the app. If you do, the chat will time out after the default 5 minutes and emit an error event. Try the prompt again; the issue is usually transient. ### "Codex tab shows installed but won't chat" Run `codex doctor` in a terminal. It reports the auth state, the model availability, and any account-level restrictions. If it says "authenticated, no model access," your ChatGPT plan doesn't include API access; upgrade to Plus, Pro, or higher. ## What Codex covers in v1 | Capability | Status | |---|---| | Streaming text responses | Yes (plain text per line) | | MCP tool use | No (Codex CLI doesn't support MCP in v1; planned for v2) | | Cost reporting | No (Codex charges against your ChatGPT subscription, no per-call cost is surfaced) | | Thinking events | No | | File attachments | No (v1) | | Browser automation | No | | Tallyfy context injection | Yes (via system-prompt prefix instead of MCP) | | Task Intent Widget | Yes (regex-based detection on Codex output) | If you need MCP tool use today, use Claude or Gemini instead; both have full MCP support in v1. - **[Connect Gemini to Tallyfy Desktop](https://tallyfy.com/products/pro/integrations/tallyfy-desktop-ai/connect-gemini/)**: Install the Google Gemini CLI via npm and sign into your Google account so Tallyfy Desktop can drive it. The Install Wizard handles npm with explicit consent, and the default model is `gemini-2.5-flash` to avoid subscription quota friction. :::note[Subscription, not API key] Gemini in Tallyfy Desktop uses OAuth via your Google account. The app never asks for a `GOOGLE_API_KEY` or `GEMINI_API_KEY` and won't accept either. A Google account is required (Workspace or personal Gmail both work); your usage counts against the free or paid Gemini quota tied to that account. ::: ## What gets installed Tallyfy Desktop drives Gemini through Google's official `gemini` command-line tool (the `@google/gemini-cli` npm package). On first launch, the desktop app checks whether `gemini` is on your `PATH` and whether you've signed in. If either is missing, it offers to install or guide you. The install command per platform is baked into the desktop app source code: | Platform | Command | |---|---| | macOS | `npm install -g @google/gemini-cli` | | Linux | `npm install -g @google/gemini-cli` | | Windows | `npm install -g @google/gemini-cli` | The binary lands in your global npm prefix. You'll need Node.js 18+ already installed. ## Prerequisites - A Tallyfy account - A Google account (Workspace or personal Gmail) - Node.js 18 or higher with `npm` available on `PATH` - A modern web browser for the OAuth sign-in step ## Option A: Install Wizard (recommended) ## Option B: Manual install ## First chat Once Gemini is connected: 1. Click the **Gemini** tab. 2. The model picker shows the default (`gemini-2.5-flash` in v2.0.0). 3. Type your message and press Enter. Gemini streams NDJSON events, so you'll see the response appear chunk by chunk with token-count stats on completion. Because the [Tallyfy MCP server](/products/pro/integrations/mcp-server/) is auto-injected, Gemini knows about your tasks, processes, templates, and team. Try: - "What templates do we have for new-hire onboarding?" - "Find all overdue tasks assigned to me" - "Launch the customer feedback survey for last month's signups" The [Task Intent Widget](/products/pro/integrations/tallyfy-desktop-ai/task-intent-widget/) works the same way it does with Claude; intent is detected and the widget surfaces inline. ## Why `gemini-2.5-flash` is the default The Gemini CLI's default model is `gemini-3-pro-preview`. In testing, that model hits "You have exhausted your capacity on this model" on most accounts after only a few prompts. Tallyfy Desktop ships with `gemini-2.5-flash` as the default to avoid that friction. You can switch to any other Gemini model from the model picker; if you hit the quota wall, switch back to `flash`. ## Verifying the install yourself ```bash # Is the binary on PATH? which gemini # Does it run? gemini --version # Are you signed in? test -f ~/.gemini/oauth_creds.json && echo "signed in" || echo "not signed in" ``` Cmd+Shift+R (Ctrl+Shift+R on Windows/Linux) in the Gemini tab forces a re-detection. ## Troubleshooting ### "You have exhausted your capacity on this model" You're hitting Google's subscription quota. The CLI auto-retries with backoff (10s, 20s, 40s) up to five attempts. If the retries don't work: 1. Switch to `gemini-2.5-flash` in the model picker; it has a higher free-tier limit 2. Wait a few minutes for the quota to reset 3. Upgrade your Google AI plan if you need higher throughput This is Google's limit, not Tallyfy's; the desktop app surfaces it cleanly but can't bypass it. ### `npm install` fails with EACCES Same fix as Codex: switch to a user-owned npm prefix or use nvm. See the [Codex install troubleshooting](/products/pro/integrations/tallyfy-desktop-ai/connect-codex/) for the same fix steps. Don't run the wizard with `sudo`. ### OAuth browser window opens to an error page Google sometimes blocks OAuth requests from new clients. The fix: 1. Sign into your Google account in the same browser first 2. Then click **Sign in with Google** in Tallyfy Desktop If the error persists, run `gemini` directly in a terminal; the CLI gives a more specific error message there. ### "Tools unavailable" warning at the start of a chat Gemini supports MCP, but the CLI loads MCP servers from a config file at `~/.gemini/settings.json`. Tallyfy Desktop writes a temporary MCP config per run (with your Tallyfy session token) and passes it to Gemini via the standard mechanism. If you see "Tools unavailable," check that you're on `gemini-cli` 0.17 or later: `gemini --version`. Older versions had bugs in MCP loading; upgrade with `npm install -g @google/gemini-cli@latest`. ## What Gemini covers in v1 | Capability | Status | |---|---| | Streaming text responses | Yes (NDJSON, full streaming with deltas) | | MCP tool use | Yes | | Cost reporting | No (only token counts) | | Thinking events | No | | File attachments | Yes | | Browser automation | No | | Tallyfy context injection | Yes (via MCP, like Claude) | | Task Intent Widget | Yes | - **[Connect Ollama to Tallyfy Desktop](https://tallyfy.com/products/pro/integrations/tallyfy-desktop-ai/connect-ollama/)**: Install Ollama on your local machine and run open-source models entirely offline. The Install Wizard handles `brew install` on macOS, the shell installer on Linux, and `winget` on Windows, then pulls a default model. :::note[No subscription, no cloud] Ollama runs entirely on your local machine. There's no account, no OAuth flow, and no subscription. Your prompts and responses never leave your computer. The only thing Tallyfy Desktop sends to the cloud is the metadata for the Tallyfy task that wraps each run (provider, model, prompt summary, duration). ::: ## What gets installed Tallyfy Desktop drives Ollama through the local daemon at `http://127.0.0.1:11434`. Unlike the other three providers, Ollama isn't a CLI you spawn per-run; it's a background service that listens on a port and accepts HTTP requests. Tallyfy Desktop talks to that service directly. The install command per platform is baked into the desktop app source code: | Platform | Command | |---|---| | macOS | `brew install ollama && brew services start ollama` | | Linux | `curl -fsSL https://ollama.com/install.sh \| sh` | | Windows | `winget install --silent --accept-source-agreements --accept-package-agreements Ollama.Ollama` | After install, Ollama runs as a background service that starts on login (macOS, Linux) or on boot (Windows). It listens only on `127.0.0.1`, so other machines on your network can't reach it. ## Prerequisites - A Tallyfy account - Enough RAM and disk space for the model you want to run (the default `llama3.2:1b` needs around 2 GB RAM and 1.3 GB disk) - Homebrew (macOS), curl (Linux), or winget (Windows) ## Option A: Install Wizard (recommended) ## Option B: Manual install ## First chat Once Ollama is connected: 1. Click the **Ollama** tab. 2. The model picker shows the models you've pulled. Pick one. 3. Type your message and press Enter. First responses are slower because Ollama loads the model into RAM on the first request. After that, it stays loaded for a few minutes and responses are fast. ## What Ollama can and can't do in v1 Ollama runs local open-source models, which have real limits compared to Claude, Codex, or Gemini: | Capability | Status | |---|---| | Streaming text responses | Yes (NDJSON streaming) | | MCP tool use | Degraded (no native MCP; falls back to system-prompt prefix with Tallyfy context) | | Cost reporting | N/A (always 0; local compute) | | Thinking events | No | | File attachments | No | | Browser automation | No | | Tallyfy context injection | Yes (via system-prompt prefix) | | Task Intent Widget | Yes | The Task Intent Widget still works because it watches the model's text output for intent patterns; it doesn't need MCP. So a small local model can still trigger a task creation when you ask for one. ## Choosing a model Tallyfy Desktop defaults to `llama3.2:1b`. That's a deliberate trade-off: small enough to run on any modern laptop, fast enough to feel responsive, but obviously less capable than larger models. A few common choices, in increasing size and capability: - `llama3.2:1b` (~1.3 GB) - the default; very fast, modest reasoning - `llama3.2:3b` (~2 GB) - better at instructions, still fast on most hardware - `mistral:7b` (~4 GB) - solid general-purpose model, needs 8+ GB RAM - `llama3.1:8b` (~5 GB) - higher quality, slower; 16+ GB RAM recommended - `qwen2.5-coder:7b` (~5 GB) - tuned for code; useful if you're using Ollama for development tasks Pull any of these with `ollama pull `, then pick it from the model picker. Larger models give better answers; smaller models give faster ones. There's no subscription cost, just disk and RAM. ## Privacy guarantee The whole point of Ollama is privacy. Tallyfy Desktop preserves this: 1. **Your prompts** go from the desktop app to `127.0.0.1:11434` on the same machine. They never touch the internet. 2. **Model responses** come back from the same local daemon. 3. **Tallyfy task metadata** (provider="ollama", model="...", prompt summary, duration) gets sent to Tallyfy as a row in the "AI Runs" checklist. The same metadata as any other run. If you want to run truly offline (no network at all, even for Tallyfy), the desktop app will queue the Tallyfy task creation and retry when network comes back. The AI run itself completes immediately. ## Verifying the install yourself ```bash # Is the binary on PATH? which ollama # Does it run? ollama --version # Is the daemon up? curl -sf http://127.0.0.1:11434/api/tags || echo "daemon not running" # What models are pulled? ollama list ``` If the daemon isn't running: - **macOS**: `brew services start ollama` (or `brew services restart ollama` if it's wedged) - **Linux**: `sudo systemctl start ollama` - **Windows**: open Services, find "Ollama", and start it Then press Cmd+Shift+R (Ctrl+Shift+R) in the Ollama tab to retry detection. ## Troubleshooting ### "Daemon not running" but the binary is installed The Ollama service might be stopped. Run the platform-specific start command above. If it still won't start, check the logs: - **macOS**: `~/Library/Logs/Homebrew/ollama/` - **Linux**: `journalctl -u ollama -n 100` - **Windows**: Event Viewer, Windows Logs, Application ### Out-of-memory error mid-chat You pulled a model bigger than your RAM. Switch to a smaller model from the picker, or pull a quantized variant (e.g., `llama3.1:8b-q4_0` instead of `llama3.1:8b`). ### Very slow first response Ollama loads the model from disk on the first request. For larger models this can take 10-30 seconds. Subsequent requests are fast. If you have a GPU (Apple Silicon, NVIDIA CUDA), Ollama uses it automatically; check `ollama ps` to see which device the model is loaded on. ### "Model not found" when picking a model You haven't pulled it yet. From a terminal: `ollama pull `. The download progress appears in the terminal; the model becomes available in Tallyfy Desktop once it finishes (you may need Cmd+Shift+R to refresh the picker). - **[Task Intent Widget](https://tallyfy.com/products/pro/integrations/tallyfy-desktop-ai/task-intent-widget/)**: The Task Intent Widget turns AI chat into Tallyfy work with one click. As you talk to Claude, Codex, Gemini, or Ollama, the widget watches for task, process, and template intent and surfaces an inline affordance to create them in Tallyfy. ## What the widget does You're chatting with Claude about next quarter's hiring plan. You say "let's create a task for me to review the candidate pipeline on Friday." Without the Task Intent Widget, that's where it ends. You'd switch to Tallyfy in another browser tab, click "new task," fill in a form, copy details over. With the Task Intent Widget, a small box appears at the bottom of Claude's chat bubble. It shows the proposed task title and a "Create task" button. Click it. Done. The task is in Tallyfy, assigned to you, due Friday, with a deep link back to the conversation. ![Task Intent Widget showing inline at the bottom of an AI chat bubble](https://screenshots.tallyfy.com/desktop-ai/task-intent-widget.png) This is the feature that makes Tallyfy Desktop different from any other AI chat app. Other chat apps end at the response. The Task Intent Widget closes the loop: AI suggests work, you confirm, Tallyfy tracks it. ## Three kinds of intent The widget recognises three kinds of intent and shows a different prefill for each: | Intent | When it fires | What the widget creates | |---|---|---| | **Create task** | The AI suggests a single piece of work ("create a task to...", "remind me to...", "let's add a todo for...") | A new task in Tallyfy with title, optional assignee, optional deadline, optional priority | | **Launch process** | The AI suggests starting a workflow ("let's launch the customer onboarding process", "run the audit template for Q3", "kick off the review workflow") | A new process from an existing template, with the kickoff form pre-filled if the AI provided enough detail | | **Edit template** | The AI suggests modifying a workflow ("we should add a step for legal review", "let's update the onboarding template to include training") | A template edit (add step, remove step, edit step), opened in a side panel for confirmation | For each kind, the widget validates the intent against your Tallyfy permissions. If you can't edit templates, the "Edit template" widget never appears. If a process name resolves to a template you don't have access to, the widget shows an error and offers to ping the template owner. ## Four widget states The widget transitions through four UI states based on what you do with it: 1. **Collapsed** - the default state. Shows a one-line summary ("Create task: Review candidate pipeline Friday") and a primary button ("Create task"). About 40 pixels tall, so it doesn't dominate the chat bubble. 2. **Expanded** - click the chevron or "edit" on the collapsed widget. Shows all the prefilled fields (title, description, assignee, deadline, priority for tasks; template, name, kickoff fields for processes; step change details for templates). You can tweak any field inline before confirming. 3. **Modal** - if the prefill is complex (e.g., a process with five kickoff fields) or ambiguous (e.g., three templates match the AI's suggestion), the widget opens a full form modal. Same fields as expanded, but with more room and the ability to pick from a dropdown when there are multiple candidates. 4. **Confirmation** - after you click the create button and Tallyfy responds with a 201. The widget replaces itself with a green check, the title of what got created, and a "View in Tallyfy" link that opens the new task or process. ## How detection works The widget uses a two-stage pipeline so it's both fast and accurate. ### Stage 1: regex (always on) As the AI streams text into the chat, a regex pattern matcher runs on each chunk. It looks for phrases that strongly suggest intent: "create a task", "add a todo", "let's launch", "we should add a step", and so on. Stage 1 is cheap, runs locally, and produces a confidence score of 0.7 for any hit. False positives are acceptable at this stage. If the widget shows up when you weren't asking for a task, click the X to dismiss it. The dismiss is sticky for that chat bubble; the widget won't reappear for the same span of text. ### Stage 2: LLM extraction (Claude only, opt-in) For Claude conversations specifically, stage 2 fires after the AI finishes its message (debounced 500ms after the last text chunk). It asks Claude itself to look at the message and extract structured intent into a JSON envelope. This catches intent that regex misses ("we ought to look at..." doesn't match a regex but obviously means "create a task to look at..."). Stage 2 runs only if: 1. The provider supports tool use (Claude in v1) 2. Stage 1 produced at least one hit on the message (to avoid LLM cost on chit-chat) 3. You haven't disabled it in settings (default on for Claude, off for everything else) When stage 1 and stage 2 disagree, stage 2 wins (it's the more accurate signal). The widget updates in place; no flicker. For Codex, Gemini, and Ollama, only stage 1 runs. Stage 2 will arrive in v2 when those providers stabilise their tool-use semantics. ## Privacy Stage 1 runs entirely on your machine. The regex patterns are baked into the desktop app source code; no remote calls. Stage 2 (Claude only) uses the same provider you're already chatting with. The extraction call is one extra prompt to Claude per message, charged to your Claude subscription (typically less than a cent per call because the extraction prompt is short). The call uses the same API session as your chat; no new authentication, no new endpoint. Tallyfy itself sees only the final action: a `POST /api/tasks`, a `POST /api/checklists//runs`, or a `PATCH /api/checklists//steps/`. The widget doesn't send your prompt text to Tallyfy. The widget doesn't log to a third-party telemetry endpoint. ## Resolving ambiguous intent A common case: you say "launch the onboarding process" and you have three templates whose names contain "onboarding" (customer, employee, vendor). The widget can't pick blindly. Here's what happens: 1. The widget detects the intent and tries to resolve the template name with a fuzzy substring search against your accessible templates 2. If zero templates match, the widget shows an error: "No template matches 'onboarding'. Pick one from the list?" 3. If one template matches with high confidence, the widget uses it and shows the name in the prefill 4. If multiple templates match (2-5), the widget escalates to the modal state and shows them all with the best match pre-selected 5. If too many match (>5), the modal shows a search box The same pattern applies to assignees ("create a task for John" with two Johns in your org) and templates for edits. ## What happens after you click "Create" The widget calls Tallyfy's API behind the scenes. The exact endpoint depends on the intent: | Intent | Endpoint | |---|---| | Create task | `POST /api/tasks` | | Launch process | `POST /api/checklists//runs` (with `templateId` resolved from the template name, if needed) | | Edit template | `PATCH /api/checklists//steps/` | The Tallyfy task or process is tagged with metadata that identifies the source: provider id, model name, run id (so you can trace it back to the Terminal Jobs entry), and a flag `source: 'desktop-intent-widget'`. This makes it easy to audit AI-generated work later: filter the Tasks view by that source tag. On success (HTTP 201), the widget transitions to the confirmation state. The deep link goes to the new item; you can pick whether it opens in the desktop app (`tallyfy://desktop-task/`) or in your browser (`https://go.tallyfy.com/...`). On failure (HTTP 4xx or 5xx), the widget shows an error state with the API error message and a "Retry" button. It does *not* collapse back; you already committed to creating something, so the widget stays visible until you either succeed or dismiss. ## Disabling the widget Some users don't want the widget to fire. You can disable it: - **Globally**: Settings, Task Intent Widget, "Enabled" toggle off. The widget never appears in any provider's chat. - **Per provider**: Settings, Task Intent Widget, Per-provider, toggle Claude / Codex / Gemini / Ollama independently. Useful if you want it for Claude but find it noisy on Ollama. - **Per chat bubble**: click the X on a widget instance. The dismiss is sticky for that specific bubble. Other widgets in other bubbles still appear. The detection cost when disabled is zero. The regex isn't even run. ## Tuning detection accuracy The widget is calibrated against a corpus of 100 example messages (30+ of which are negative examples like sarcasm, hypotheticals, or chit-chat that shouldn't trigger). The current calibration aims for precision >= 0.85 and recall >= 0.75 on that corpus. If you find the widget firing too often or too rarely on your messages, [tell support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/) the prompt text and what you expected. Real-world miscalibrations feed back into the test corpus. ## What it looks like in each provider The widget UI is identical across providers; what changes is the detection signal: - **Claude** - both stages run; the highest accuracy. Tool-use events from Claude's MCP calls can also trigger the widget (e.g., if Claude calls the Tallyfy `create_task` MCP tool, the widget reflects what was created). - **Gemini** - stage 1 only in v1. Detection accuracy is lower than Claude. - **Codex** - stage 1 only. Plain text stream means the widget watches Codex's response chunks for patterns. - **Ollama** - stage 1 only. Works the same as Codex; quality depends on how clearly the local model articulates intent. ## When the widget is the moat If you're evaluating Tallyfy Desktop against other AI clients, the widget is the differentiator. Plenty of apps let you chat with Claude. Almost none of them let you turn that chat into structured work in a workflow system with one click. The widget is also the answer to "why use Tallyfy Desktop instead of the web client." The web client doesn't have any AI providers at all. The desktop app does, and the widget binds them to Tallyfy. - **[Terminal Jobs tab](https://tallyfy.com/products/pro/integrations/tallyfy-desktop-ai/terminal-jobs/)**: The Terminal Jobs tab is your persistent log of every AI run in Tallyfy Desktop. Each run is also a Tallyfy task, so the same history appears in your Tallyfy account. Local SQLite, tiered cancellation, and full streaming output replay. ## What the Terminal Jobs tab is The Terminal Jobs tab is the Tallyfy Desktop view of every AI run you've ever started. Each row is one run: provider, model, prompt summary, start time, duration, status, and cost (where the provider reports it). Click any row to expand a panel that shows the full streamed output of that run. Think of it as the desktop app's process monitor for AI work. If Activity Monitor is to the OS what Terminal Jobs is to your AI history. ![Terminal Jobs tab with several entries showing provider, model, duration, and status](https://screenshots.tallyfy.com/desktop-ai/terminal-jobs.png) ## Every run is also a Tallyfy task The v2.0.0 invariant: every AI run, including local Ollama runs, creates a row in a system Tallyfy checklist called "AI Runs." The checklist is created automatically on your first run. The task records: - The provider (Claude, Codex, Gemini, Ollama) - The model name - A short summary of the prompt (first 80 characters) - The start and end timestamps - The cost in USD (where the provider reports it; 0 for Ollama and Codex) - The terminal status (success, error, cancelled) - A deep link back to the desktop app: `tallyfy://desktop-run/` If something fails, the task stays. It's marked with the error code so you can see what happened from any device that has access to your Tallyfy account. This is what makes Terminal Jobs and Tallyfy work in tandem: | View | Lives on | Best for | |---|---|---| | Terminal Jobs tab | Your local SQLite database | Real-time view of running jobs, full streamed output replay, cancellation | | AI Runs checklist in Tallyfy | Tallyfy cloud | Cross-device run history, audit log, automation triggers on AI activity | If you have Tallyfy Desktop installed on two computers, each one has its own Terminal Jobs tab (showing only that machine's runs), but the Tallyfy "AI Runs" checklist shows every run from every machine. ## Reading a run row Each row shows: - **Provider icon** - Claude, Codex, Gemini, or Ollama - **Model** - the exact model name (e.g., `claude-sonnet-5`, `gemini-2.5-flash`) - **Prompt summary** - the first 80 characters of your prompt - **Started** - relative timestamp (e.g., "3 minutes ago"), with the exact UTC timestamp on hover - **Duration** - end minus start, in seconds or minutes - **Cost** - USD cost reported by the provider, or "n/a" for Ollama and Codex - **Status** - one of: - **Running** - active right now, with a spinner - **Success** - completed without error - **Error** - hit an error code; expand to see the message and recovery hint - **Cancelled** - you (or the system) cancelled it before completion The row also shows the run id (a short hash). Pass it to the desktop app's command palette or paste it into a Tallyfy task comment to deep-link the run. ## Viewing run details Click any row to expand the detail panel. It shows: 1. **Full prompt** - what you typed 2. **Streamed output** - the assistant's response, exactly as it appeared in the chat, including any tool use blocks 3. **Thinking blocks** (Claude only) - collapsed by default; expand to see the model's reasoning 4. **Tool calls** - each MCP or Tallyfy tool the AI invoked, with input parameters and output 5. **Token usage** - input tokens, output tokens, and cache stats (Claude only) 6. **Terminal event** - the final `result` or `error` from the provider The detail panel is read-only. To re-run the same prompt, click **Open in chat**; the original chat session reappears in the corresponding provider tab with the prompt pre-filled. ## Cancelling a running job Click the cancel button (X icon) on any row whose status is "Running." Tallyfy Desktop uses a tiered cancellation policy: 1. **SIGINT** - sent first. The CLI gets a clean interrupt; most providers stop within a second or two. 2. **SIGTERM** - sent after 2 seconds if SIGINT didn't take. Forces a process termination. 3. **SIGKILL** - sent after another 5 seconds if SIGTERM didn't take. Unconditional kill. The cancelled run emits a clean `error` event with code `cancelled` and the Tallyfy task is updated with status `cancelled`. Token usage and partial output up to the cancel point are preserved. For Ollama runs (which talk to the local daemon over HTTP), cancellation propagates an `AbortSignal` through the HTTP request; the daemon stops generating tokens within a few milliseconds. ## Filtering and search The Terminal Jobs tab has a search bar at the top. Type any of: - A provider name (e.g., `claude`) to filter to that provider's runs - A model name (e.g., `gemini-2.5-flash`) - A keyword from the prompt - A status (e.g., `error`, `cancelled`) - A date (e.g., `today`, `yesterday`, `2026-05-19`) Filters combine: `claude error today` shows Claude runs that failed today. There's also a quick-filter strip at the top: - **All** - default - **Running** - active jobs only - **Today** - runs started today (your local timezone) - **Failed** - status error or cancelled - **Costly** - runs over a threshold (default $0.50 USD; configurable in settings) ## Local SQLite storage The Terminal Jobs data lives in a SQLite database on your machine at: - **macOS**: `~/Library/Application Support/Tallyfy/runs.db` - **Windows**: `%APPDATA%\Tallyfy\runs.db` - **Linux**: `~/.config/Tallyfy/runs.db` Why local: AI runs can contain sensitive prompts (HR conversations, contract drafts, code with API keys you accidentally pasted). Storing the raw event stream locally means the only cloud copy is the Tallyfy task metadata, which is much narrower. The database has three tables: - `runs` - one row per run, with the columns shown in the tab - `events` - the full AIEvent stream for each run (text chunks, tool calls, errors) - `tasks` - the mapping from run id to Tallyfy task id The `events` table can grow quickly if you have long chats. Tallyfy Desktop auto-prunes events older than 90 days (the `runs` and `tasks` rows stay; only the streaming detail is dropped). Pruning can be disabled in settings. ## Exporting runs For compliance or audit, you can export run data: 1. Click any run row to expand it 2. Click **Export** at the bottom of the detail panel 3. Pick **JSON** (raw events) or **Markdown** (readable transcript) The export includes everything the local database has for that run. The Tallyfy task is not included in the export (it's already in Tallyfy; query that side for the audit-trail view). ## Privacy guardrails A few things Terminal Jobs does *not* do: - It doesn't send the raw streamed events to Tallyfy. Only the metadata (provider, model, prompt summary, cost, duration) makes it to the Tallyfy task. - It doesn't send anything to a third-party telemetry endpoint. Tallyfy Desktop's optional telemetry covers feature usage, not run content. - It doesn't store your Tallyfy session token in `runs.db`. The token is in the OS keychain; runs.db only stores the run id and the Tallyfy task id. ## What this enables Because every AI run is a Tallyfy task, you can do things that wouldn't be possible if the runs lived only inside the desktop app: - **Trigger automations on AI activity**. Set up a Tallyfy automation: when an AI Run task is created with cost > $1, notify the team. - **Audit AI usage by user**. Filter the AI Runs checklist by assignee to see who's using the most AI time. - **Cross-device continuity**. Start a long-running Claude job on your laptop; check its status from your phone via the Tallyfy mobile app. - **Tie AI runs to processes**. If an AI run created a task in another Tallyfy process, you can see the chain in the task's metadata. The [Task Intent Widget](/products/pro/integrations/tallyfy-desktop-ai/task-intent-widget/) is the inbound side of this loop. Terminal Jobs is the outbound side: it's the audit trail of every run that happened. ### Webhooks - **[Send emails using webhooks](https://tallyfy.com/products/pro/integrations/webhooks/how-can-i-send-emails-using-webhooks-in-tallyfy/)**: Connect Tallyfy webhooks to middleware tools like Zapier or Make to automatically send custom emails with full process context when workflow events like task completions happen. ## Trigger custom emails from Tallyfy webhooks Tallyfy's [webhooks](/products/pro/integrations/webhooks/) send JSON data to external URLs whenever key events happen, like a task getting completed or a process being launched. Pair this with a [middleware](/products/pro/integrations/middleware/) tool (Zapier, Make, or Power Automate) and you can automatically fire off custom emails based on those events. The webhook payload includes task details, form field values, assignee info, and process data, so your emails can pull in all the context they need. ### What you need - A Tallyfy account on a paid plan. - An account with a middleware service (Zapier, Make, Power Automate, etc.). - A basic grasp of how webhooks and middleware automations work. :::note[Picking a middleware tool] Zapier works well for simple email notifications. Make.com or Power Automate give you more control for complex scenarios. Developers can also build custom webhook receivers directly. ::: ### General setup steps The exact steps vary by middleware tool, but here's the overall flow: #### Step 1: Get a webhook URL from your middleware tool #### Step 2: Configure the webhook in Tallyfy You can set webhooks at two levels in Tallyfy: on a specific step, or on the entire template. Tallyfy sends the webhook as a POST request with an `X-Tallyfy-orgID` header identifying your organization. #### Step 3: Set up the email action in your middleware tool #### Step 4: Customize your email ### Testing and going live - Run a test process in Tallyfy and complete the trigger step. - Check that the email arrives and looks right. - Once it's working, turn ON the automation in your middleware tool. That's it. Every time that step gets completed, your custom email fires automatically. - **[Webhook scenarios](https://tallyfy.com/products/pro/integrations/webhooks/how-can-i-use-tallyfys-webhooks-feature/)**: Tallyfy webhooks push JSON data to external systems when processes launch, complete, or when tasks finish. Each payload carries all form fields and metadata collected up to that point. ## Common ways to use Tallyfy webhooks Tallyfy's webhooks automatically send data to external systems when specific events happen in your workflows. Three main events can trigger a webhook: ### Trigger: process launched Set up a webhook at the template level. It fires *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 in a spreadsheet or database). ### Trigger: task completed Set up a webhook on a specific step within a template. It fires 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" is completed, send data to your finance system). ### Trigger: process completed A template-level webhook also fires when all tasks in a process are completed. This lets you trigger external actions when an entire workflow finishes, not just individual tasks. * **Use case**: Mark a deal as "closed" in your CRM or archive records when a full process wraps up. ### Video examples These videos show practical ways to use webhooks, often with a middleware tool like Zapier: :::note[Middleware choice] These examples use Zapier, but the same concepts work with 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** Shows 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 JSON data. You can see an example of the structure here: [Webhook-Sample.json](https://screenshots.tallyfy.com/Webhook-Sample.json) :::tip[Webhooks carry ALL data up to that point] When a webhook fires, it carries ALL information collected in the process up to that 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, guest links, and context One webhook gives you everything that's happened so far. You don't need separate webhooks for each piece of data. ::: #### Webhook payload structure The JSON payload contains detailed event information. Key sections for **task completion** webhooks include: - **`this_task`**: The task that triggered the webhook - includes `id`, `title`, `alias`, `status`, `summary`, `deadline`, `position`, `captures` (form field values), `owners` (assigned users and guests), `completed_at`, `completed_by`, and `assets` (attached files with download links). - **`next_task`**: The first incomplete task that isn't auto-skipped, ordered by position. Includes the same fields as `this_task` (minus assets). Returns an empty object if all tasks are done. - **`process`**: The overall process instance - includes `id`, `organization_id`, `name`, `summary`, `status`, `progress`, `created_at`, `ClientURL`, `prerun` (kick-off form values), `process_forms` (all form field values across all tasks), and `tags`. - **`template`**: The source template - includes `id`, `title`, `alias`, and `summary`. - **`form-fields`**: A flat map of all form field values across all tasks and the kick-off form, keyed by alias. - **`process-tasks`**: A map of task aliases to task IDs for the entire process. - **`guest-links`**: URLs for each guest assignee to access their tasks. - **`launcher`** and **`completer`**: Info about who launched the process and who completed the task. For **process launch/completion** webhooks, the payload includes process data, `process-tasks`, `ko-form-fields` (kick-off values), `guest-links`, and `launcher`. Refer to the sample JSON file linked above for the full structure. ### Date formats Tallyfy lets you choose between two date formats for webhook data. You select this in your organization settings: - **ISO format** (default): `yyyy-MM-ddTHH:mm:ssZ` - **Human-readable format**: `d/m/Y h:i A T` - dates are converted to your organization's timezone ![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 header Tallyfy webhooks include an `X-Tallyfy-orgID` header containing your unique organization ID. Your receiving system can check this header to validate that the request 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] Webhooks might fire more than once for the same event. For example, if a task is completed, then reopened and completed again, you'll get multiple webhook notifications. Your receiving system should implement [idempotency handling](/products/pro/integrations/handling-idempotency-in-webhooks-and-api/) to avoid processing the same event twice. ::: - **[Set up webhooks](https://tallyfy.com/products/pro/integrations/webhooks/how-to-set-up-webhooks-in-tallyfy/)**: Tallyfy webhooks POST JSON data to external URLs when workflow events like step completions or process launches happen. Configure them at template or step level, with built-in security through the X-Tallyfy-orgID header. ## How webhooks work in Tallyfy Tallyfy webhooks send automated JSON messages to external systems when specific workflow events happen. They POST data to URLs you define, giving you real-time integration with other apps. This guide covers how to set them up and avoid common pitfalls. ### Webhook types Tallyfy has two webhook levels: #### Template-level webhooks Template-level webhooks fire when **any step** in a process is completed, when a process is launched, or when a process is completed. They send the full process data - all form fields and step statuses. Think of these as the "firehose" option. **When a step has its own webhook URL set, that takes priority** over the template-level webhook for that specific step. **Use cases:** - Track overall process progress in external systems - Update dashboards when any step changes - Capture new process launches or completions #### Step-level webhooks Step-level webhooks fire only when a **specific step** is completed. More surgical - they only trigger when that particular step is done. **Use cases:** - Send notifications at key process milestones - Trigger follow-up actions in other systems - Export 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, process launch, or process completion. Step-level webhooks only fire for that specific step. - **Priority** - If a step has its own webhook URL, it's used instead of the template-level webhook for that step's completion event. - **Security** - The `X-Tallyfy-orgID` header is included in every webhook request. Always validate this in your receiving system. ### Setting up template-level webhooks ### Setting up step-level webhooks ### Example: Slack notifications via middleware Here's how to send Slack notifications when an employee completes an onboarding step in Tallyfy. #### What you'll need - Tallyfy account with Professional or Enterprise plan - Middleware account (Make.com, Power Automate, n8n, or Zapier) - Slack workspace with admin access :::note[Choosing the right middleware] Compare 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 and capabilities. For maximum control, especially if you have dev resources, consider using Tallyfy's [Open API](/products/pro/integrations/open-api/) to build custom integrations with AI-generated code for serverless functions. ::: #### Step 1: Set up the middleware webhook receiver #### Step 2: Configure the Slack message action #### Step 3: Configure the Tallyfy webhook #### Step 4: Test the integration ### Security Tallyfy includes the `X-Tallyfy-orgID` header in all webhook requests. Validate this header against your organization's ID to confirm the webhook is legitimate - you 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[Handle duplicate webhook events] Webhooks can fire multiple times for the same event. For example, if a task is completed, then reopened and completed again, you'll get multiple notifications. Always implement [idempotency handling](/products/pro/integrations/handling-idempotency-in-webhooks-and-api/) to prevent duplicate actions. It's much easier to handle this from the start than debug it later. ::: ### Troubleshooting **Webhooks not firing?** Here's how to diagnose: 1. **Verify the URL is correct** - Copy and paste it fresh, don't type it manually 2. **Check URL accessibility** - Test your webhook URL with 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 receivers require HTTPS, not HTTP 6. **Look for auth requirements** - Your receiver might be rejecting unauthenticated requests 7. **Verify step completion** - Webhooks only fire when steps are actually completed (not just opened) :::tip[Testing webhooks] **Always test with webhook.site first.** Get a unique URL there, use it in Tallyfy, then complete a task. You'll see exactly what data Tallyfy sends. Once you've confirmed data is flowing, switch to your real webhook URL. ::: :::note[Webhook delivery behavior] Tallyfy attempts each webhook delivery once. If the receiving server is unreachable or returns an error, the delivery isn't retried. Currently, webhook delivery failures aren't visible in the Tallyfy UI. We're building a customer-visible System Log that will show webhook delivery attempts, successes, and failures - coming soon. ::: ### Best practices - Use HTTPS URLs for webhook destinations - HTTP is asking for trouble - Validate the `X-Tallyfy-orgID` header in your receiving system - Test webhooks before relying on them in production - Monitor webhook delivery using your middleware platform's logs - Build retry logic into your receiving system for reliability - Use webhook.site or RequestBin for initial testing before connecting production systems - Validate the payload structure on your end - don't assume it won't change - **[Webhook payload structure](https://tallyfy.com/products/pro/integrations/webhooks/webhook-payload-structure/)**: Tallyfy webhook payloads deliver JSON data in two formats. Process-level payloads contain full process state and kick-off form data when processes launch or complete. Task-level payloads contain completed task details along with all accumulated form fields, a next_task reference pointing to the first visible incomplete task, and guest-links that provide direct access URLs for external collaborators. ## How webhook payloads work When Tallyfy sends a webhook to your endpoint, it delivers a JSON payload with data about the event. The structure depends on the 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 actual structure produced by Tallyfy's API code, not theoretical examples. If you're building an integration, you'll want to use these structures as your guide. ## Process-level webhook payload Process-level webhooks fire when someone launches a new process or when a process completes. They 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 (map of field timeline ID => field value) │ ├── 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 │ └── 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": { "a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6": "Widget Suppliers Inc", "3c9d1e7fa4b820516d8e2f7a9c0b4d15": "Service Agreement", "9f2b7c1e4a6d8035b1c7e9d2f4a6b801": "50000", "6e4a2c80f19b3d75e0a8c246b93f157d": "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" } } ``` :::note[Two ways to read the same kick-off answers] This payload gives you the kick-off form answers twice, keyed differently, and it's easy to mix them up: - `prerun` is keyed by each field's **timeline ID**, a 32-character hex string. - `ko-form-fields` is keyed by each field's **alias**, the readable name like `vendor-name`. Pick whichever suits your code. Aliases read better, though they change if someone renames the field, while timeline IDs stay put. One thing to watch: if you're launching processes through the [API](/products/pro/launching/triggers/via-api/), its `prerun` object only accepts timeline IDs. Copying alias keys out of `ko-form-fields` into a launch request won't work, and Tallyfy discards keys it can't match without reporting an error. Each `prerun` value's shape depends on the field type. The per-type list lives on [Launch process](/products/pro/integrations/open-api/code-samples/processes/launch-process/). ::: ## Task-level webhook payload Task-level webhooks fire when a specific task completes. They contain detailed info about the completed task, all process data collected so far, and the next task that needs attention. **What's `next_task`?** It's the first visible incomplete task ordered by position number. "Visible" means it wasn't auto-skipped by automation rules. "Incomplete" means it hasn't been completed yet (includes tasks that are in-progress). Returns an empty array `[]` if all tasks in the process are done. ### 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 (NO version field) │ ├── 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 │ └── 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": { "a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6": "Widget Suppliers Inc", "3c9d1e7fa4b820516d8e2f7a9c0b4d15": "Service Agreement", "9f2b7c1e4a6d8035b1c7e9d2f4a6b801": "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 The `guest-links` object provides direct access URLs for all guest assignees in a process. You can use it to send personalized emails or SMS notifications to guests with direct links to their assigned tasks. There's no need to generate separate links - they're included automatically. ### Structure ```json "guest-links": { "guest.email@company.com": { "link_for_guest": "https://go.tallyfy.com/guest-all-task/{org_id}/{guest_code}" } } ``` ### Key details - **Included in both webhook types** - process-level and task-level - **All unique guests** - every unique guest assigned anywhere in the process - **Direct access** - links bypass login, so guests click and see their tasks - **Persistent codes** - guest codes stay stable across the process lifecycle ### Common use cases - **Custom email notifications** - build your own notification system using Zapier or 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. Here's how each one works. ### 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" } ``` This format applies to all date fields across the webhook payload. It's consistent regardless of where the date field appears. ## Task assignment info 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, keyed by field timeline ID const kickoffData = webhookPayload.process.prerun; // Example: { "a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6": "Widget Suppliers Inc", ... } ``` Kick-off answers show up in `form-fields` as well, under their alias. Reach for `prerun` when you want them on their own, and remember its keys are timeline IDs rather than the readable names you see in `form-fields`. ### Triggering follow-up actions Use the `next_task` object to prepare for upcoming steps: ```javascript const nextTask = webhookPayload.next_task; // next_task is an empty array [] when all tasks are done 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 let you collect documents from external people by generating unique upload URLs and embedding them into Tallyfy workflow tasks. Recipients can upload files directly without needing accounts, while your team keeps full control over storage and compliance. ## What are file request links? File request links let you collect documents from people who don't have access to your systems. Your document management system (DMS) generates a unique URL. Anyone with that link can upload files to a specific folder - they don't need an account, can't see other files, and can't access anything else. You keep full control over storage, access, and compliance. ## How file request links work with Tallyfy ## Real-world example A legal firm launches a client onboarding process in Tallyfy. During launch, they generate unique Box file request links for each document type (contracts, IDs, financial records) and store them in text fields. The client receives tasks with clear instructions: "Upload your documents here: [link]". They click, upload directly to the firm's Box account, and documents land in the correct client folder. The firm maintains attorney-client privilege while the client gets a straightforward experience. ## Setting up your workflow You'll need three things: **Template configuration** - Add short text form fields to capture file request URLs during process launch. **Variable insertion** - Use variables to insert these URLs into task descriptions or form instructions. **Clear instructions** - Write task descriptions that explain what documents to upload and show the link prominently. ## Security benefits **No account required** - External users upload without creating accounts or remembering passwords. **Limited access** - Uploaders can't see, edit, or download existing files. **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 existing infrastructure. ## Common use cases ### Legal services Collecting evidence, contracts, and IDs from clients while maintaining privilege. ### Healthcare Gathering medical records, insurance cards, and consent forms 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 keep documents separated. **Set expiration dates** - Configure links to expire after a reasonable timeframe. **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 before going live. ## Choosing your DMS platform Not every platform handles file requests the same way: Some platforms, like Google Drive, don't have native file request features and need third-party tools for anonymous uploads. Check your platform's capabilities before designing your workflow. ## Automation possibilities You can automate link generation for more advanced setups: - 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 ## 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** - Make sure your DMS allows anonymous uploads and "Anyone" links are enabled. **Missing files** - Confirm uploads completed successfully and check the correct folder in your DMS. ### File request links - **[Box file requests](https://tallyfy.com/products/pro/integrations/document-management/file-request-links/box/)**: Box file requests let you securely collect files from anyone, even without a Box account, by generating unique upload links tied to specific folders. They support identity verification and metadata collection that integrate into Tallyfy workflows. ## What are Box file requests? Box File Request lets you collect documents from anyone - even people without Box accounts. Requires a Business plan or higher, but you get strong security controls suited to 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 ## Security features **Identity verification** - Require uploaders to sign in with a Box account (free accounts work). Captures their verified email with every upload. **Email validation** - Even without Box login, you can require uploaders to verify their email. **Access controls** - Your Box admin can enforce org-wide policies for all file requests. **Virus scanning** - All uploads are scanned automatically before they're accessible. ## What uploaders see 1. Your custom message explaining what files you need 2. Sign-in or email verification (if configured) 3. Required metadata fields to fill out 4. Drag-and-drop or browse to select files 5. Box uploads and notifies you (if enabled) ## Metadata collection Require structured information with each upload: ```text Example metadata setup: - Uploader Email: [Required] - Document Type: [Dropdown: Contract, Invoice, Receipt] - Reference Number: [Text field] - Description: [Text area] ``` Metadata stays attached to files, making them easier to find later. ## Using Box file requests with Tallyfy **Simple collection** - One Box file request link per process, shared across tasks. **Categorized uploads** - Separate file requests per document type: - Financial → /Client Files/Financial/ - Legal → /Client Files/Legal/ - Identity → /Client Files/Identity/ **Maximum security** - Unique file requests per process instance with short expiration windows. ## Automation options Box's API supports: - Creating file requests programmatically - Webhook notifications when files arrive - Auto-moving uploads to permanent storage - Triggering Tallyfy API calls on upload completion ## Managing active links 1. Go to your folder on Box.com 2. Check the sharing panel for active requests 3. Disable links once collection is done 4. Review upload history in the admin console ## Best practices **Folder organization** - Mirror your process structure in your Box folder hierarchy. **Naming conventions** - Use consistent naming like `[Process]-[Date]-[Client]`. **Regular cleanup** - Disable old file request links quarterly. **Monitor usage** - Check Box's audit logs to see who's uploading. ## Limitations **Business plan required** - File requests aren't available on personal Box accounts. **Single folder destination** - Each request points to one folder. You can't split uploads dynamically. **No conditional logic** - Can't show or hide metadata fields based on previous selections. ## Alternative - Box folder invites For trusted partners who have 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 More features, but requires Box accounts on both sides. ## Troubleshooting **"Access denied"** - Your org admin may have restricted file requests. **Missing metadata** - Confirm required fields are set in file request settings. **Upload failures** - Check file size limits (5 GB default, up to 250 GB). **Link not working** - The link may be disabled or expired. ## Cost considerations File requests come with Business plans but count toward your storage quota. Watch usage if you collect large files often. - **[Dropbox file requests](https://tallyfy.com/products/pro/integrations/document-management/file-request-links/dropbox/)**: Dropbox file requests let anyone upload files to your Dropbox folder without needing an account. Store these unique upload links in Tallyfy process fields to collect documents from external users during workflow tasks. ## Creating Dropbox file requests for Tallyfy workflows Anyone can upload files to your Dropbox without needing an account, and you control exactly where those files land. It's one of the simplest file request tools available. ## Prerequisites You'll need a Dropbox account with file request capabilities: - **Basic/Plus/Family plans** - files up to 2 GB each - **Professional/Business plans** - files up to 250 GB each - **Business plans** - deadlines and password protection options ## Creating your first file request ## What uploaders see When someone clicks your file request link, they get a simple upload page with your title and description. They drag and drop files (or click to browse), optionally enter their name and email, then click **Upload**. That's it. 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 so you can match uploads to specific workflows. **Create unique requests per process** - Don't reuse links across instances. A fresh request per run keeps documents clearly separated. **Set reasonable deadlines** - If your plan supports it, align deadlines with your process timeline plus a buffer. **Monitor the folder** - Set up Dropbox notifications for new uploads so nothing slips through. ## Handling multiple file types If a process needs different document types, create separate file requests with distinct destination folders: ``` Passport Documents → /Client Files/[Name]/Passport/ Tax Documents → /Client Files/[Name]/Tax/ Medical Records → /Client Files/[Name]/Medical/ ``` Store each link in a separate Tallyfy text field and reference them in the relevant tasks. ## Security considerations Dropbox file requests are secure by default: - Uploaders can't see existing files in your folder - Each request URL is unique and unguessable - You can close requests manually anytime - Business accounts can require passwords - Dropbox scans all uploads for viruses ## Limitations **File size limits** vary by plan - 2 GB for personal, 250 GB for business. **No automatic upload notification** - You won't know files arrived unless you've configured folder watching. **Name and email are optional** - Uploaders can skip identifying themselves. ## Automation options Dropbox provides a file requests API (`/2/file_requests/create`) for creating requests programmatically. You can also: - Pre-create batches of file requests and store links in a spreadsheet - Use Dropbox folder actions to trigger notifications when files arrive - Use middleware tools like Zapier to connect Dropbox upload events to Tallyfy ## 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, Dropbox shared folders work too: 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 You get more collaboration features, but everyone needs a Dropbox account. - **[Google Drive file requests](https://tallyfy.com/products/pro/integrations/document-management/file-request-links/google-drive/)**: Google Drive doesn't have a built-in file request feature. Collect files from external users through third-party tools like FileDrop or File Request Pro, Google Forms, or shared folders with managed access. ## File requests for Google Drive 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. Several workarounds exist though - from third-party tools to Google Forms. ## Why Google Drive can't do this natively Google requires authentication for all file uploads. Recipients must have a Google account, sign in, and have explicit upload permissions. That's a problem when you're collecting documents from clients or vendors who don't use Google. ## Option 1 - Third-party file request tools These services create upload forms that connect directly to your Google Drive. ### FileDrop FileDrop creates upload forms that save straight to your Google Drive: **Pricing**: Free tier available with limitations, paid plans for higher volumes. ### File Request Pro File Request Pro adds features like custom branding, file type restrictions, size limits, email notifications on upload, and metadata collection fields. **Setup**: Connect Google Drive, create a request, copy the link to Tallyfy. ### Other alternatives - **JotForm** - form builder with Google Drive integration - **Formfacade** - converts Google Forms to allow file uploads - **Upload Files to Drive** - 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, which defeats the purpose for most external collection scenarios. ## Option 3 - Shared folder with managed access When everyone involved has a Google account: ## Option 4 - Google Workspace automation If your organization uses Google Workspace, you can build a custom upload endpoint with 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 this as a web app. It requires technical setup but gives you full control over the upload flow. ## 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, keep these in mind: - **Data flow** - files pass through the third-party service before reaching Google Drive, so make sure the service meets your security standards - **Access scope** - review which Google Drive permissions you're granting and limit to specific folders when possible - **Compliance** - verify the tool meets your industry's standards (HIPAA, GDPR, etc.) ## Tips for implementation - Test the full upload flow before adding it to production workflows - Tell uploaders exactly what file types and sizes you'll accept - Set up Google Drive notifications so you know when new files arrive - Move processed files to archive folders to keep upload destinations clean - **[SharePoint file requests](https://tallyfy.com/products/pro/integrations/document-management/file-request-links/sharepoint/)**: SharePoint and OneDrive file requests let you generate unique upload-only links that anyone can use to submit files into specific folders. Uploaders don't need a Microsoft account, and all uploads include audit trails and malware scanning. ## Using SharePoint and OneDrive file requests SharePoint and OneDrive for Business use the same file request technology. You can 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 with existing SharePoint permissions. ## Prerequisites - SharePoint Online or OneDrive for Business account - Admin must enable file requests - "Anyone" link sharing must be allowed in your tenant - Not 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 simple on purpose: 1. They click your link and see a clean upload page 2. SharePoint asks for their first and last name 3. They select or drag files to upload 4. Files go directly to your specified folder 5. They get a confirmation when done Each uploaded file gets prefixed with the uploader's name. ## Security and compliance **Upload-only access** - Users can only add files, not view, edit, or delete existing content. **Audit trails** - All uploads are logged in SharePoint's audit system. **Data location** - Files stay in your tenant's geographic region per 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. ## Automating with Power Automate You can automate file request link generation: ``` Example workflow: 1. Tallyfy triggers Power Automate when a process starts 2. Power Automate creates a new SharePoint folder 3. Generates a file request link for that folder 4. Updates the Tallyfy process with the link via API 5. Sends upload instructions to the recipient ``` This removes manual link creation while keeping unique upload destinations per process. ## Integration patterns for Tallyfy **Department-based collection** - Create permanent file request links per department: - HR uploads → /HR Submissions/ - Finance uploads → /Finance Documents/ - Legal uploads → /Legal Files/ **Time-based organization** - Generate monthly folders with matching file requests: - January → /Uploads/YYYY-01/ - February → /Uploads/YYYY-02/ **Process-specific folders** - Create unique folders and file requests per process instance. ## Managing file requests To 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. ## Limitations **Expiration** - Links expire based on admin configuration (typically 30 days). **File naming** - SharePoint adds the uploader's name as a prefix. You can't disable this. **No metadata collection** - Unlike Box, you can't add custom fields to the upload form. **Special characters** - Some special characters in filenames may cause upload issues. ## Troubleshooting **"This link has expired"** - Create a new file request. Links expire after the configured period. **"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 landed in a subfolder, or if the uploader's name prefix is causing confusion. ## Alternative - Teams integration For internal workflows, Teams channels can work too: 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 drag and drop files directly This gives you more collaboration features but requires Teams access. ## Admin requirements If file requests aren't working, your admin needs to: 1. Enable "Anyone" links in SharePoint admin center 2. Set `OneDriveRequestFilesLinkEnabled` to `$true` 3. Set `OneDriveRequestFilesLinkExpirationInDays` (1-730 days) 4. Make sure your SharePoint site allows external sharing ### Mcp server - **[Using Tallyfy MCP server with Claude (text chat)](https://tallyfy.com/products/pro/integrations/mcp-server/claude-anthropic/)**: Connect Claude to Tallyfy's hosted MCP server to manage workflows in plain language. Add it as a custom connector in Claude.ai or Claude Desktop, sign in with OAuth, then query tasks, analyze processes, and combine with Computer Use for visual automation. ## Chat with Claude to run your Tallyfy work Connect Claude to Tallyfy and you can manage your work just by chatting. Ask Claude about your tasks, launch and review processes, or build a template, and it does the work in your Tallyfy account for you. It works in the Claude Desktop app and on claude.ai, on any paid Claude plan. :::note[Which Claude feature is this?] This page covers **Claude's text chat** connecting to your Tallyfy data. That's different from [Claude Computer Use](/products/pro/integrations/computer-ai-agents/vendors/claude-computer-use/), which controls a screen visually (mouse, keyboard, screenshots). Use text chat here for data questions, analysis, and automation. Use Computer Use for visual tasks that need clicking around an interface. ::: ### What you can do Once it's connected, you talk to Claude in plain language and it works in Tallyfy for you. For example, you can ask it to: - **Run your day.** Show today's tasks, flag anything overdue, and build a prioritized action list. - **Find and fix stalled work.** Spot processes that have stopped moving, figure out what's blocking them, and suggest next steps. - **Shuffle work around.** Reassign all of someone's open tasks to a colleague when they go on vacation. - **Build and improve templates.** Turn a flowchart into a ready-to-run template, or review an existing process and suggest improvements. - **Pull reports.** Generate an SOP from a template, or a compliance report showing completion times and any missed deadlines. Claude also asks before it acts. When a request is vague, it pops up a short set of questions to confirm what you mean before it touches your account, so it doesn't guess. ### See it in action Real screenshots from claude.ai with the Tallyfy connector active. Each one shows a different thing Claude can do. A user dropped a flowchart into Claude and asked for a matching template. Claude built a 7-step Business Trip Request with 5 if-then rules - approval gates, parallel notifications, and conditional show/hide on rejection. ![Claude creating a 7-step Business Trip Request template in Tallyfy with 5 automation rules matching a flowchart](https://screenshots.tallyfy.com/tallyfy/pro/mcp-claude-template-creation.png) Claude doesn't guess. When the question is ambiguous, it surfaces a structured picker so you confirm scope before any tools fire. Here Claude needs to know whose tasks, what counts as pending, and how to define "next month" before it'll touch your account. ![Claude.ai Cowork sidebar showing the Tallyfy connector connected, with Claude asking four clarifying questions before querying pending tasks](https://screenshots.tallyfy.com/tallyfy/pro/mcp-claude-clarifying-questions.png) Asked to review a Client Onboarding process and suggest improvements, Claude first confirms what you actually want - suggest only, suggest then edit on approval, or edit directly - then routes the rest of the run based on your answer. ![Claude.ai Cowork sidebar reviewing a Client Onboarding process and confirming scope with four options including suggest only, edit on approval, edit directly, or something else](https://screenshots.tallyfy.com/tallyfy/pro/mcp-claude-process-review.png) For a bigger question, the right-side progress sidebar shows Claude working in steps - reading your profile, pulling your tasks, then counting and double-checking. The result here: 822 open tasks, 805 of them already overdue, and 0 due in the next 30 days because everything is already past its date. Claude flagged the surprise and offered three follow-up paths instead of just answering the literal question. ![Claude.ai answering a pending-tasks question against the Tallyfy MCP server, with the progress sidebar showing four completed sub-steps and a detailed breakdown of 822 open tasks - 805 overdue and 17 auto-skipped](https://screenshots.tallyfy.com/tallyfy/pro/mcp-claude-overdue-analysis.png) ### Good to know - **It's text, not the visual app.** You won't see Tallyfy's visual tracker, flowcharts, or progress bars in the chat. A process that's three-quarters done comes back as the words "75% complete." When you want the visual view, pull the data in Claude, then open Tallyfy's web app. - **It's not live.** Claude checks when you ask. It won't ping you on its own when a task changes, so you ask it to check, or set up alerts in Tallyfy for urgent items. - **Forms get flattened.** Rich forms become plain text, long dropdowns get listed out, file uploads need a separate step, and dates become typed text. - **Everything runs as one person.** The connection uses a single Tallyfy identity, so every action shows up under the account that set it up. You can't switch accounts mid-chat. ### Is it secure? Yes. You sign in with your own Tallyfy account to authorize the connection, and the Claude Desktop app keeps your sign-in token in your computer's secure keychain (macOS Keychain or Windows Credential Manager), never in plain text. All traffic runs over HTTPS, and you should handle the data you pull with the same GDPR and CCPA care as any other system. The full security setup is under [For developers](#for-developers). ## For developers *(Skip this unless you're setting up the technical side.)* Tallyfy's MCP server is hosted at `https://mcp.tallyfy.com/` (note the trailing slash, no `/mcp/` suffix) and listed on the [Official MCP Registry](https://registry.modelcontextprotocol.io/?q=tallyfy) as `com.tallyfy/mcp-server`. The server speaks the standard streamable-http transport, authenticates via OAuth 2.1 with Dynamic Client Registration, and exposes the same 109 tools to all Claude clients (Desktop, claude.ai connectors, Claude Code). Access tokens carry the canonical `mcp_resource` claim so the server can bind the token to the resource it was issued for. Claude Desktop was the first AI assistant to offer native MCP integration. The Anthropic family that supports remote MCP today includes Claude Opus, Sonnet, and Haiku models on Pro, Max, Team, and Enterprise plans, plus Claude Code in VS Code, JetBrains, and GitHub Actions. The remote setup uses OAuth, with no local installation required. ### MCP architecture flow [Diagram removed for brevity] **Key points:** - Tallyfy hosts the MCP server at mcp.tallyfy.com and Claude reaches it over the network (streamable HTTP) - there's nothing to install or run locally - You authorize once with OAuth 2.1: you sign in with your Tallyfy account and Claude stores the token securely, so there's no API key to paste - Claude auto-discovers tools from the MCP server and shows them with the hammer icon ### Claude Desktop MCP support Claude Desktop's MCP features include: - **Native MCP client** with full protocol support - **Desktop Extensions**: One-click .mcpb installation bundling servers with all dependencies - **Remote MCP servers**: URL-based connection with OAuth 2.1, hosted on Cloudflare - **Transport**: stdio for local servers, **Streamable HTTP** for remote (SSE is deprecated) - **Security**: OS keychain integration (macOS Keychain, Windows Credential Manager) - **Plans**: Available on Pro, Max, Team, and Enterprise (not Free) - **Platforms**: macOS and Windows - **Tool discovery**: Auto-detects and displays available MCP tools - **Governance**: MCP is governed by the Agentic AI Foundation under the Linux Foundation (since December 2025) ### Prerequisites - A paid Claude plan (Pro, Max, Team, or Enterprise) - remote connectors aren't on Free - Claude.ai in a browser, or the latest Claude Desktop app - A Tallyfy account you can sign in with - you authorize through OAuth, so there's no API key to paste ### Other MCP servers and directories Official MCP servers you can pair with Tallyfy: - **GitHub**: Repos, issues, PR workflows - **Stripe**: Payment processing - **PayPal**: Inventory, payments, shipping, refunds - **Slack**: Team communication with Real-time Search API - **Linear**: Project management with OAuth remote MCP - **Sentry**: Error tracking - **PostgreSQL, MySQL, MongoDB**: Database operations with schema inspection - **Filesystem**: Local file access with sandboxed controls - **Brave Search**: Privacy-focused web search - **Atlassian**: Jira and Confluence via remote MCP - **ServiceNow**: Workflow automation MCP directories: - **PulseMCP (pulsemcp.com)**: Large, regularly updated directory - **mcpservers.org**: Community collection synced with GitHub - **MCP Market (mcpmarket.com)**: Figma, Databricks, Storybook connectors - **mcp.so**: Anthropic's community platform with server registry ### Connect the Tallyfy MCP server You don't build or run anything - Tallyfy hosts the server at `https://mcp.tallyfy.com`. You add it as a remote connector and sign in once. Claude discovers the OAuth endpoints automatically, so there's no JSON to edit and no API key to paste. **In Claude.ai (web):** **In Claude Desktop:** For the full step-by-step with screenshots, see [Claude integration](/products/pro/integrations/byo-ai/claude-integration/). ### Example prompts **Task management** ``` Find all tasks assigned to me due this week and create a summary report. ``` Claude will query Tallyfy via the `search_tasks` tool, filter by user and date range, format a structured report, and optionally save it locally via filesystem MCP. **Stalled process detection** ``` Check for stalled processes in our "Customer Onboarding" template and suggest next actions. ``` Claude queries active processes, identifies tasks that haven't progressed, analyzes blockers, and provides recommendations. **Bulk reassignment** ``` Reassign all of John's open tasks to Sarah - he's on vacation. ``` Claude finds John's tasks, filters for open status, reassigns them, and summarizes the changes. More prompts that work well: ``` Show me all tasks due today, any overdue items, and processes needing my attention. Create a prioritized action list. ``` ``` Analyze the last 50 completed 'Customer Onboarding' processes. Find the steps with longest completion times and suggest improvements. ``` ``` Generate an SOP document for our 'Invoice Processing' template with all steps, responsible parties, and average completion times. ``` ``` Review team member skills and current workload, then suggest optimal task assignments for next week's projects. ``` ``` Create a compliance report showing all 'Data Access Request' processes from last quarter, including completion times and SLA violations. ``` ### Claude Desktop features for Tallyfy #### Projects for persistent context Claude Desktop's **Projects** feature lets you create a project per workflow or client. Upload process docs once and reference them across sessions. Task history persists between conversations - ideal for managing processes that span weeks or months. Projects also support memory - Claude extracts and saves key facts to maintain continuity. Extended thinking lets it work through multi-step problems, alternating between reasoning and tool calls. #### Local file system integration Unlike web-based AI, Claude Desktop can access your local files: ```json { "mcpServers": { "filesystem": { "command": "npx", "args": [ "-y", "@modelcontextprotocol/server-filesystem", "/Users/username/Documents/Tallyfy" ] } } } ``` This lets you read process docs from disk, export Tallyfy data to CSV, and sync local templates. #### Tool composition Connecting multiple MCP servers is where Claude Desktop gets powerful. Example multi-server workflow: 1. Filesystem MCP reads a CSV of 50 new employees 2. Tallyfy MCP creates onboarding processes for each 3. Slack MCP notifies the HR team with status updates 4. GitHub MCP creates IT access tickets #### Developer tools - MCP server logs: `~/Library/Logs/Claude/` (macOS) or `%APPDATA%\Claude\logs\` (Windows) - Built-in tool call debugging - Claude Code: VS Code and JetBrains extensions with inline diffs - Remote MCP servers on Cloudflare with OAuth - no local setup - GitHub Actions support for CI/CD workflows ### Combining MCP with Computer Use Pair Claude's text-based MCP with [Claude Computer Use](/products/pro/integrations/computer-ai-agents/vendors/claude-computer-use/) for broader automation: **MCP handles**: API data queries, bulk operations, report generation, data-driven decisions **Computer Use handles**: Visual interfaces, third-party form filling, UI navigation, apps without APIs #### Example hybrid workflow **Step 1 - MCP** (data gathering): ``` Analyze all completed audit processes this month, identify non-compliance issues, and export a summary with statistics to CSV. ``` **Step 2 - Computer Use** (visual automation): ``` Open the government compliance portal, navigate to the monthly report section, and fill in the form using the CSV data. Screenshot each step for audit trail. ``` #### Hybrid best practices 1. **MCP for data** - API access is faster and more reliable than UI automation 2. **Computer Use for UI-only tasks** - only when there's no API available 3. **Files for data transfer** - pass data between MCP and Computer Use via local files 4. **Watch costs** - Computer Use with screenshots costs more than MCP API calls 5. **MCP is more predictable** - API operations are deterministic; visual automation isn't ### Security 1. **Configuration security** - Desktop Extensions encrypt credentials via OS secure storage (Keychain, Credential Manager) - Mark fields as `"sensitive": true` in manifest.json for auto-encryption - Store API keys in environment variables, not plaintext JSON - Set file permissions: `chmod 600 claude_desktop_config.json` 2. **MCP server isolation** - Run servers with minimal permissions - Remote MCP uses OAuth 2.1 with PKCE. Tallyfy's endpoints: - Authorization: `https://go.tallyfy.com/mcp/oauth/authorize` - Token: `https://go.tallyfy.com/mcp/oauth/token` - Dynamic Client Registration: `https://go.tallyfy.com/mcp/oauth/register` - OAuth discovery via `/.well-known/oauth-authorization-server` (RFC 8414) - Available scopes follow the pattern `mcp.{resource}.{action}` - for example: `mcp.tasks.read`, `mcp.tasks.write`, `mcp.processes.read`, `mcp.templates.write`, `mcp.users.read`, `mcp.forms.read`, `mcp.automation.write` - Log all API calls with timestamps for auditing 3. **Data handling** - Claude Desktop stores conversations locally in `~/Library/Application Support/Claude/` - Projects maintain persistent context - review what you're sharing - Consider GDPR/CCPA compliance when handling user data 4. **Network security** - HTTPS required for all API communications - Remote MCP eliminates local attack surface but needs internet - Implement exponential backoff for retries ### Advanced configuration #### Other MCP servers alongside Tallyfy You add Tallyfy itself through the connector UI above (no config file needed). To run extra local servers next to it - for example, filesystem and GitHub - edit `claude_desktop_config.json`: ```json { "mcpServers": { "filesystem": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "~/Documents"] }, "github": { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-github"], "env": { "GITHUB_TOKEN": "ghp_xxx" } } } } ``` #### Custom server tips 1. **Use TypeScript for type safety** ```typescript import { Server } from '@modelcontextprotocol/sdk/server/index.js'; import { TallyfyClient } from './tallyfy-client'; ``` 2. **Handle errors properly** ```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** ```javascript console.error(`[Tallyfy MCP] ${new Date().toISOString()} - ${request.method}`); ``` ### Known issues 1. **Windows paths**: Use forward slashes `/` or double backslashes `\\` in JSON configs 2. **Large datasets**: Paginate when pulling 1000+ items - Claude truncates big responses 3. **Idle disconnects**: Implement retry logic with exponential backoff 4. **Memory growth**: Restart Claude Desktop periodically during heavy use 5. **Rate limits**: Vary by plan tier - track your usage 6. **SSE deprecated**: Use Streamable HTTP for new integrations 7. **Remote MCP needs internet**: Local stdio servers work offline; remote ones don't ### Claude vs ChatGPT for MCP **Claude Desktop**: - Mature MCP implementation with Desktop Extensions (.mcpb) - Remote MCP on Cloudflare with OAuth - Extended thinking with tool use - Computer Use for hybrid automation **ChatGPT/OpenAI**: - MCP in Agents SDK with Responses API - Desktop MCP for Team/Enterprise with custom connectors - Deep Microsoft integration (Teams, Office, Azure) **Choose Claude** for the most mature MCP experience, Desktop Extensions, Projects for persistent context, and Computer Use hybrid workflows. **Consider ChatGPT** for Microsoft integration or enterprise admin-controlled connectors. ### Best practices 1. **Start with read-only** operations before adding write capabilities 2. **Test in sandbox** - never test against production Tallyfy data 3. **Document tools** with clear descriptions and `inputSchema` definitions 4. **Version your servers** using semantic versioning in manifest.json 5. **Track API usage** - Claude enforces rate limits per plan 6. **Package as .mcpb** for easy distribution via Desktop Extensions 7. **Return proper error codes** - not raw exceptions - **[Tallyfy MCP server with Google Gemini](https://tallyfy.com/products/pro/integrations/mcp-server/google-gemini/)**: Connect Tallyfy's MCP server to Gemini CLI, Gemini Code Assist, and Gemini Enterprise. Run OAuth 2.1 with Dynamic Client Registration for the CLI surfaces, and add Tallyfy as a Custom MCP Server data store for enterprise teams. ## Run Tallyfy by chatting in Google Gemini Connect Tallyfy to Google Gemini and you can run your workflows just by typing in plain English. Ask Gemini to find your overdue tasks, launch a process, or point out where work is getting stuck, and it does the work in Tallyfy for you. No clicking through screens. There are three ways to connect, and which one you pick depends on who's using it. The setup for each is further down, under [For developers](#for-developers). ### What you can do Once Tallyfy is connected, you just talk to Gemini and it handles the rest. For example, you can ask it to: - Find all your overdue tasks and summarize them grouped by who they're assigned to. - Look at last month's onboarding processes and point out where they slow down. - Review one of your templates and suggest ways to improve it. - Watch your running work and flag anything at risk of missing its deadline, with a guess at why. Because Gemini lives inside Google's tools, you can also mix Tallyfy with the rest of them. Pull process timings next to data in BigQuery, kick off a review in Tallyfy when a new file lands in Cloud Storage and ping the team in Gmail, or have Gemini read an image or document as part of a review. Gemini handles pictures and files, not just text. ### Which way should you connect? - **Gemini CLI** - the command-line tool, for developers who work in a terminal. - **Gemini Code Assist** - the same thing, but inside the VS Code or IntelliJ code editor. - **Gemini Enterprise** - for a whole team. Your Google Cloud admin sets it up once, then everyone can use it. This one is in Preview right now. The first two take about a minute. The Enterprise setup is more involved and your Google admin handles it. All three steps are under [For developers](#for-developers). ### Good to know - **Enterprise is in Preview.** As of May 2026, the Gemini Enterprise setup screens and field names may still change. - **Your admin turns tools on.** After Enterprise setup, each Tallyfy tool starts switched off. An admin enables the ones your team should use. - **Chat is text only.** Gemini shows you text, so Tallyfy's visual tracker won't appear in the chat. You ask for status updates in words instead. - **Tallyfy isn't in a public Gemini directory.** Each organization adds Tallyfy itself using the steps below. It won't show up on its own. ### Is it secure? Yes. You sign in with your own normal Tallyfy login through OAuth[^1], the same secure sign-in standard banks and big apps use, so you never paste a password into Gemini. Your sign-in is tied to your Tallyfy organization, and access tokens refresh on their own in the background. Enterprise teams also get Google's Vertex AI controls and audit logs in Cloud Logging. Full details are in [For developers](#for-developers). ## For developers *(Skip this unless you're setting up the technical side.)* ### Server endpoints Tallyfy publishes two endpoints for Gemini, and they behave identically: - **Primary:** `https://mcp.tallyfy.com/` (hosted on DigitalOcean). - **Google Cloud Run mirror:** `https://mcp-gcp.tallyfy.com/` (the Tier-1 choice for Gemini Enterprise). Both expose the same 109 tools and share the same OAuth backend, so your access tokens work on either one. The server is listed on the [Official MCP Registry](https://registry.modelcontextprotocol.io/?q=tallyfy) as `com.tallyfy/mcp-server`. The Cloud Run mirror is operationally identical to the primary endpoint but runs on Google Cloud Run. For Gemini Enterprise that means lower-latency egress, easier VPC Service Controls and Cloud Logging integration, and an origin that lives inside Google's compliance perimeter. The deploy pipeline (Cloud Build, then Artifact Registry, then Cloud Run) is fully operational, and every push to the MCP server repo deploys to both endpoints in parallel. Pick whichever endpoint your AI surface prefers - the data and behavior are the same. ### Gemini MCP support status - **Gemini CLI** - remote streamable-HTTP MCP via `~/.gemini/settings.json`; OAuth auto-discovered through DCR and PKCE. - **Gemini Code Assist** - same configuration schema as Gemini CLI in VS Code; IntelliJ uses `mcp.json`. - **Gemini Enterprise** - Custom MCP Server data store (Preview); per-organization configuration in the Google Cloud Console. - **Apigee integration** - an optional path for converting managed APIs into MCP servers (not needed for Tallyfy; we publish our own server directly). ### Prerequisites - A Tallyfy account with an active organization. - For the Gemini CLI path: `@google/gemini-cli` installed (`npm install -g @google/gemini-cli`). - For Gemini Code Assist: the Code Assist extension installed in VS Code or IntelliJ, signed in to a Google account with Gemini access. - For Gemini Enterprise: Discovery Engine Editor IAM role (`roles/discoveryengine.editor`) plus the ability to override the org policy that blocks custom MCP server data stores. ### Connect Tallyfy in Gemini CLI ### Connect Tallyfy in Gemini Code Assist ### Connect Tallyfy in Gemini Enterprise Gemini Enterprise's Custom MCP Server data store (Preview as of May 2026) is configured per-organization by your Google Cloud admin. The connection setup happens entirely on Google's side. There's no approval step or vendor signup at Tallyfy. ### How Gemini calls Tallyfy When you ask in plain language, Gemini picks the right Tallyfy tools and runs them: - *"Find all overdue tasks and create a summary grouped by assignee."* Gemini calls `search_for_tasks` with an overdue filter, groups by assignee, and writes a summary. - *"Analyze our customer onboarding processes from the last month and identify bottlenecks."* Gemini queries process history through MCP tools, computes per-step completion times, and surfaces the slowest steps. - *"Review our Invoice Processing template and suggest improvements."* Gemini fetches the template with `get_template`, walks the step dependencies and automation rules, and proposes changes. Because Gemini runs inside Google's platform, you can combine Tallyfy data with other Google services: - **BigQuery** - analyze Tallyfy process data alongside your data warehouse. For example, correlate support tickets in BigQuery with support process completion times in Tallyfy. - **Cloud Run** - deploy your own MCP logic at scale. - **Pub/Sub** - drive event-based workflow triggers, such as kicking off a document review in Tallyfy when a file lands in Cloud Storage. - **Vertex AI agents** - build multi-agent systems with the Agent Development Kit that combine Tallyfy with other services under Google's governance controls. Gemini's multimodal input also lets it process images and documents alongside text, which helps with visual inspection workflows or document review processes. ### Security and authentication - **Authentication** - OAuth 2.1. Gemini CLI and Code Assist register as PKCE public clients through DCR. Gemini Enterprise registers as a confidential client through DCR using `client_secret_basic` or `client_secret_post` (both advertised by the server in its `/.well-known/oauth-authorization-server` metadata). All flows use S256 PKCE for the code challenge. Refresh tokens rotate automatically. - **Data handling** - Google processes your data per their AI policies. Enterprise teams get Vertex AI controls and audit logging in Cloud Logging. - **Network** - All traffic over HTTPS. Enterprise deployments can add VPC Service Controls and private connectivity. [^1]: OAuth is the standard that lets you sign in to one app using another account, without sharing your password. - **[Using Tallyfy MCP server with ChatGPT](https://tallyfy.com/products/pro/integrations/mcp-server/openai-chatgpt/)**: ChatGPT Enterprise and Team users can connect to Tallyfy's MCP server through OAuth 2.1 to manage workflows and search tasks using natural language. The text-based interface works well for queries but can't replace Tallyfy's visual UI. ## Run your Tallyfy work from ChatGPT Connect Tallyfy to ChatGPT and you can manage your workflows just by typing what you need. Ask ChatGPT to find tasks, review a template, or pull a report, and it does the work in your Tallyfy account for you. It's available on ChatGPT Team, Enterprise, and Education plans. ChatGPT is text only, so it's great for searching, analyzing, and planning, but it can't show you Tallyfy's visual screens. The setup steps are under [For developers](#for-developers). ### What you can do Once it's connected, you talk to ChatGPT in plain language and it works in Tallyfy for you. For example, you can: - **Search in plain English.** "Find all templates related to employee onboarding that include background check steps." ChatGPT searches names, descriptions, and step content, and finds it in seconds. - **Get form-field suggestions.** Ask it to add the right fields to collect customer feedback in a process, and it suggests fields with sensible validation rules. - **Try out automations safely.** Ask "if I route tasks by deal value, how would these 5 deals get assigned?" and it simulates the result without touching your live processes. - **Keep docs and templates in sync.** Paste an updated procedure and ask ChatGPT to update the matching template, highlighting what changed. - **Spot patterns worth keeping.** Have it review the one-off tasks people added to a process last month and suggest which ones belong in the template for good. - **Answer hard questions.** "Which step in our sales process takes longest, and who's fastest at it?" It analyzes your data and answers, with links to the exact processes it looked at. ### Good to know ChatGPT is a chat window, so anything that needs Tallyfy's visual screens won't work well here: - **No visual tracker.** You can't see Tallyfy's progress bars, color-coded statuses, or workflow diagrams, so spotting bottlenecks or SLA risk at a glance isn't possible. For charts and trends, connect a BI tool to [Tallyfy Analytics](/products/pro/integrations/analytics/) instead. - **Forms get flattened.** Long dropdowns become a wall of text, dates turn into typed text, and you can't upload files. - **Building [templates](/products/pro/documenting/templates/) is clumsy.** There's no drag-and-drop to reorder steps, no visual branching, and no preview. - **Bulk work is slow.** Reassigning 50 tasks means 50 commands or one risky bulk instruction, and big lists come back as pages of text. - **It's not live.** ChatGPT only checks when you ask, so you won't see a teammate's change until your next query, and two people can't edit the same template at once. The takeaway: use ChatGPT for search, analysis, and planning, then jump into Tallyfy's visual interface to actually run the work. ### Which ChatGPT plans you need Team, Enterprise, and Education plans can connect Tallyfy as a custom app (after turning on Developer Mode). Plus and Pro plans get pre-built connectors and any installed apps from the directory. ### Is it secure? Yes. You sign in with your own Tallyfy account to authorize the connection and choose which organization to connect. A couple of good habits: connect with an account that has only the permissions ChatGPT needs (not a full admin account), review which templates hold sensitive data, and check your access logs now and then. The full setup and security notes are under [For developers](#for-developers). ## For developers *(Skip this unless you're setting up the technical side.)* ### Server endpoint and support status The MCP server is hosted at `https://mcp.tallyfy.com/` and exposes 109 tools. ChatGPT supports it through Custom Connectors (Team, Enterprise, Education plans) and through ChatGPT Apps (when you've installed it from the apps directory). The server is also published on the [Official MCP Registry](https://registry.modelcontextprotocol.io/?q=tallyfy) as `com.tallyfy/mcp-server`. A verification endpoint at `https://mcp.tallyfy.com/.well-known/openai-apps-challenge` confirms ownership for OpenAI's Apps directory; Tallyfy is published in OpenAI's apps directory as `Tallyfy Workflow Automation`. - **Availability** - Team, Enterprise, and Education plans support custom MCP server connections via Developer Mode. Plus and Pro plans get pre-built connectors and installed apps from the directory. - **Access method** - Developer Mode (custom connector) and ChatGPT Apps (from the directory) - **Operations** - Full read/write via Developer Mode, read-only via Deep Research - **Authentication** - OAuth 2.1 with PKCE (per RFC 8414) via `/.well-known/oauth-authorization-server`, with Dynamic Client Registration (RFC 7591) - **Scopes** - Dot notation like `mcp.tasks.read`, `mcp.processes.write`, `mcp.templates.read` - **Apps SDK** - The MCP server is the same one ChatGPT Apps and any Custom Connector consume, so Apps SDK content shares the same backend You must enable Developer Mode in ChatGPT settings to use MCP servers in regular conversations. ### Prerequisites - ChatGPT Enterprise, Team, or Education subscription - A Tallyfy account with organization access - Access to create custom apps in ChatGPT - Familiarity with OAuth authentication flows ### Set up Tallyfy in ChatGPT ### Example prompts **Finding overdue tasks** ``` Using Tallyfy, find all overdue tasks assigned to the marketing team and summarize them by priority. ``` What happens: ChatGPT calls `search_for_tasks` with an overdue filter, filters results by marketing team assignment, groups findings by priority, and returns a formatted summary. **Analyzing template health** ``` Analyze our "Customer Onboarding" template in Tallyfy and suggest improvements. ``` What happens: ChatGPT calls `get_template` to pull template details, runs `assess_template_health` for complete template data, runs `analyze_template_automations` for automation analysis, and suggests specific optimizations. **Creating workflow documentation** ``` Generate documentation for our "Invoice Processing" workflow, including all steps and form fields. ``` What happens: ChatGPT retrieves the template structure using `get_template`, lists all steps with descriptions, documents form fields for each step, and includes automation rules. These prompts also work well: ``` Find all templates related to employee onboarding that include background check steps ``` ``` Add appropriate form fields to collect customer feedback in our support process ``` ``` If I set up an automation to assign tasks based on deal value, show me how it would route these 5 example deals ``` ``` Here's our updated SOX compliance procedure. Update our audit template to match these new requirements, highlighting what changed ``` ``` Analyze one-off tasks added to our hiring processes last month and suggest which should be added to the template ``` ``` Which step in our sales process has the longest average completion time, and which team members are fastest at completing it? ``` ### Limitations of the text-based interface ChatGPT's text interface hits real walls with certain Tallyfy features: - **Form field interactions** - Dropdowns, multi-selects, and complex inputs don't translate well to plain text. A dropdown with 20+ options becomes a wall of text. Date pickers become "type the date in YYYY-MM-DD format." File uploads aren't possible at all. - **Visual workflow representation** - ChatGPT can't display Tallyfy's visual process tracker or workflow diagrams. You lose step-by-step flow visualization, real-time progress updates, and dependency mapping. - **Bulk operations** - Reassigning 50 tasks means 50 individual commands (or one complex bulk instruction that might fail). Filtering and sorting large process lists produces pages of text. Batch template updates give no visual confirmation. - **Real-time collaboration** - ChatGPT's turn-based model doesn't support live updates. Your teammate finishes a task, and you won't know until you ask again. Notifications get buried in conversation history. Two people can't work on the same template simultaneously. Features that specifically don't render well: the visual **Tracker View** (progress bars and color-coded statuses), the drag-and-drop template builder (no visual branching logic or structure preview), advanced filtering and saved views, and analytics (no charts, graphs, or trend visualizations - connect your BI tools to [Tallyfy Analytics](/products/pro/integrations/analytics/) for those, and build [templates](/products/pro/documenting/templates/) in Tallyfy's own UI). ChatGPT does shine at natural-language search, what-if automation simulations, and complex questions about your [processes](/products/pro/tracking-and-tasks/processes/). ### Security considerations 1. **Access control** - Use accounts with minimal required permissions. Consider a dedicated service account for the ChatGPT integration. 2. **Data sensitivity** - Review which templates and processes contain sensitive information. Audit data access logs regularly. 3. **Prompt injection** - Be cautious of templates or data containing prompt-like text. Verify unexpected ChatGPT behaviors and report suspicious activity to both OpenAI and Tallyfy support. ### Known issues 1. **Deep Research is read-only** - Enable Developer Mode in ChatGPT Settings for write operations 2. **Session timeouts** - Long-running queries may timeout after 60 seconds 3. **Context window limits** - Large template structures may exceed token limits 4. **No real-time updates** - Changes in Tallyfy aren't reflected until the next query 5. **Limited file handling** - Can't process attachments or generate files 6. **No webhook support** - Can't trigger or respond to Tallyfy webhooks 7. **Terminology** - OpenAI renamed "connectors" to "apps" in December 2025, so some docs may use the old term ### Best practices 1. **Be specific** - Instead of "show me tasks," try "show me high-priority tasks assigned to John due this week" 2. **Batch requests** - Combine related queries in a single prompt 3. **Ask for analysis** - Request insights and patterns, not just raw data 4. **Save effective prompts** - Reuse prompts that work well for common workflows 5. **Combine with Tallyfy's UI** - Use ChatGPT for analysis and planning, then execute in Tallyfy's visual interface ### What's next - **Write capabilities** - Already available via Developer Mode - **OAuth 2.1** - Live now with PKCE and Dynamic Client Registration - **Apps SDK** - Build custom UIs alongside MCP servers - **OpenAI Apps directory listing** - Tallyfy's submission is in progress; the verification challenge endpoint at `/.well-known/openai-apps-challenge` is already live - **Real-time sync** - Live updates between ChatGPT and Tallyfy (coming soon) OpenAI and Tallyfy are both expanding MCP features. MCP is governed by the Agentic AI Foundation under the Linux Foundation. - **[Using Tallyfy MCP server with Microsoft Copilot Studio](https://tallyfy.com/products/pro/integrations/mcp-server/microsoft-copilot-studio/)**: Connect Tallyfy's MCP server to Microsoft Copilot Studio through Power Platform custom connectors. Automate workflows and manage processes via natural language with enterprise security features like VNet isolation and DLP policies. ## Run your workflows from Microsoft Copilot Studio Connect Tallyfy to Microsoft Copilot Studio and your team can run Tallyfy workflows by chatting with an AI agent. Ask an agent to start a process, assign tasks, or pull a status report, and it does the work in Tallyfy for you. If your company already runs on Microsoft tools, this fits right in. Setup goes through a Power Platform custom connector, so it's more involved than a plug-and-play chat tool. Someone comfortable with Power Apps or Power Automate handles it once, then everyone uses it. The full steps are under [For developers](#for-developers). ### What you can do Once it's connected, you talk to a Copilot Studio agent and it handles Tallyfy for you. For example, you can: - **Split a process across several agents.** Onboard a new hire and let one agent handle the HR tasks, another the IT setup, and another the training schedule, all tracked in one Tallyfy process. - **Tie Tallyfy into the rest of your Microsoft tools.** Start a Tallyfy process when a new deal shows up in Dynamics 365, open a Teams channel for it, and report progress in Power BI. - **Run compliance and audit work.** Review this quarter's audit processes and generate a report in SharePoint, with anything that breaks the rules flagged for the compliance team. - **Find and fix bottlenecks.** Have an agent look across your processes, point out where work slows down, and suggest changes. ### What you need - A Microsoft Copilot Studio license (trial or paid). - A Tallyfy credential: either your Tallyfy API key from your organization settings, or a Tallyfy account to authorize through OAuth. The steps below use the API key, because it is the quicker of the two to wire up. - Access to Power Apps or Power Automate, to build the connector. - Generative Orchestration turned on in your Copilot Studio agent. - An environment in a region where this is available. ### Good to know - **It takes real setup.** You connect through a Power Platform custom connector, so plan for someone who knows Power Apps or Power Automate to wire it up and test it. - **It costs more.** MCP needs Generative Orchestration, which is an add-on, and your monthly message limit depends on your plan (roughly 25,000 to 200,000 messages). Some features need their own Power Platform licenses too. - **It's region-limited.** MCP and some preview features aren't available everywhere yet, and data-residency rules may restrict where you can use it. - **Heavy security adds a little delay.** Extra protections like keeping traffic on a private network add a few milliseconds, and large result lists come back split into pages. ### Is it secure? Yes. Two separate sign-ins are involved, and it helps to keep them apart. You get into Copilot Studio with your normal Microsoft account, and your IT team can add the same protections they use for any other Microsoft app: keeping traffic on a private network, blocking sensitive data from leaving, requiring a second sign-in step, and keeping full audit logs. Admins can see every connected agent in the Microsoft 365 admin center. The connector then authenticates to Tallyfy separately, with a **Tallyfy** credential. Your Microsoft account does not sign you in to Tallyfy. You can use either a Tallyfy API key or OAuth 2.1[^1]; see [Which credential to use](#which-credential-to-use) for the difference. The exact settings are under [For developers](#for-developers). ## For developers *(Skip this unless you're setting up the technical side.)* ### Server endpoint and support status The MCP server is hosted at `https://mcp.tallyfy.com/` and exposes 109 tools across 14 categories. It's listed on the [Official MCP Registry](https://registry.modelcontextprotocol.io/?q=tallyfy) as `com.tallyfy/mcp-server`. Copilot Studio connects to it over streamable HTTP. Tallyfy is already a Microsoft Verified Publisher with a [Power Automate connector](https://learn.microsoft.com/en-us/connectors/tallyfy/) that's been live for years, so the MCP path is the natural next step for AI-driven workflow ops on the Microsoft stack. Direct MCP support inside Copilot Studio (skipping the custom-connector wrapper) is under active investigation with Microsoft. MCP server support is generally available in Copilot Studio as of early 2026: - **Transport**: Streamable HTTP only (SSE is deprecated) - **MCP resources**: Files and images supported in responses - **Enterprise features**: VNet integration, DLP, multiple auth methods - **Admin visibility**: MCP-enabled agents visible in M365 admin center - **Platform integration**: Native Power Platform connector infrastructure - **Prebuilt connectors**: GitHub, Asana, Jira, Dataverse, Dynamics 365, Microsoft Fabric - **Governance**: MCP governed by Agentic AI Foundation under Linux Foundation (December 2025); Microsoft is a founding member ### Which credential to use The server accepts **two** credentials, and both work today. Pick one and keep the whole connector consistent with it. | | Tallyfy API key | OAuth 2.1 | |---|---|---| | How it travels | `Authorization: Bearer ` | `Authorization: Bearer ### How the pieces connect This diagram shows how Tallyfy's MCP server connects with Copilot Studio through Power Platform infrastructure. [Diagram removed for brevity] **What to notice:** - Setup involves multiple Microsoft services (Azure, Power Apps, Copilot Studio) configured in sequence - Authentication happens at the Power Apps connector level using your Tallyfy API key - DLP policies add a security layer for enterprise deployments ### Multi-agent orchestration Copilot Studio can coordinate multiple specialized agents for workflows like employee onboarding. [Diagram removed for brevity] **What to notice:** - The Primary Agent acts as an orchestrator, delegating to specialized agents - Each agent creates and manages its tasks through Tallyfy's API - All progress is monitored through Tallyfy's tracker view A few worked examples of agents in action: - **Multi-agent onboarding.** Prompt: *"Start the employee onboarding process for Jane Smith, assign tasks to HR and IT, and schedule training sessions."* The primary agent receives the request, delegates documentation tasks to the HR agent (via Tallyfy), system-access setup to the IT agent, and session scheduling to the Training agent, monitors progress across all of them, and reports a consolidated status back to you. - **Power Platform integration.** Prompt: *"When a new sales opportunity is created in Dynamics 365, start our proposal process in Tallyfy and create a Teams channel for collaboration."* A Power Automate flow triggers on the Dynamics 365 opportunity, the MCP server creates a Tallyfy process instance, the Teams connector creates a dedicated channel, and the agent monitors and reports progress. - **Enterprise compliance.** Prompt: *"Review all completed audit processes this quarter and generate a compliance report with any violations highlighted."* The agent queries Tallyfy for audit process data, analyzes completion times against SLAs, checks for required approvals, generates a formatted report in SharePoint, and routes it to the compliance team if violations are found. More example prompts that work well here: - *"When a purchase order exceeds $50,000 in Dynamics 365, initiate our approval workflow in Tallyfy, notify team leads in Teams, and track in Power BI."* - *"Monitor all SOX compliance processes, ensure proper segregation of duties, and generate audit reports with full trail documentation."* - *"Coordinate our product launch process across marketing, sales, and operations teams, with each department's agent handling their specific tasks."* - *"Analyze our customer service processes to identify bottlenecks, suggest optimizations, and automatically implement approved changes."* - *"Manage our FDA submission process with full audit trails, approval chains, and automatic compliance checking at each step."* Multi-agent setups delegate tasks between specialized agents, keep context across agent handoffs, give you central monitoring of the whole workflow, and include built-in error handling and fallback. ### Power Platform features - **Power Automate flows** - trigger 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 Copilot Studio also gives you a tools and prompts framework: a **prompt library** to create and share custom prompts across agents, a **tool catalog** to browse and install prebuilt MCP connectors, **version control** to track changes to tools and prompts, and a **testing framework** to validate tools before deployment. ### Enterprise architecture Recommended architecture for large organizations needing 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 remove the need to store credentials in code Common deployment shapes, from simplest to most involved: **Basic (small organizations)** ``` [Copilot Studio] → [Custom Connector] → [Tallyfy MCP Server] → [Tallyfy API] ``` **Enterprise (large organizations)** ``` [Copilot Studio] ↓ (VNet Integration) [API Management] ↓ (Private Endpoint) [App Service Environment] ├── [MCP Proxy Instance 1] ├── [MCP Proxy Instance 2] └── [Load Balancer] ↓ (Managed Identity) [Tallyfy MCP Server] ``` **Hybrid (multi-cloud)** ``` [Copilot Studio] → [ExpressRoute] → [On-premises Proxy] → [Tallyfy MCP Server] ↘ ↗ [Azure Proxy] → [Tallyfy MCP Server] ``` ### Security - **Network security** - deploy within VNet for isolation, use Private Endpoints, implement WAF rules, enable DDoS protection. - **Authentication** - use Azure AD, implement service principal auth for server-to-server, apply conditional access policies, enable MFA. - **Data protection** - classify data sensitivity levels, apply DLP policies, enable encryption at rest and in transit. - **Monitoring** - enable Azure Monitor, configure anomaly alerts, maintain audit logs for compliance. You also get Microsoft's enterprise features directly: VNet integration to isolate MCP traffic within your network, Data Loss Prevention (DLP) policies to prevent data exfiltration, Azure AD authentication that reuses your existing identity management, and inherited Microsoft compliance certifications. ### Limitations - **Licensing complexity** - MCP requires Generative Orchestration (additional cost), message limits vary by plan (25K to 200K messages/month), some features need Power Platform licenses too, and multi-agent orchestration may still be in preview for some customers. - **Regional availability** - MCP is available in limited regions initially, data residency requirements may restrict usage, and preview features are often US-only at launch. - **Connector development overhead** - you must create OpenAPI specifications, Power Apps/Automate knowledge is needed, testing takes longer than direct MCP connections, and versioning or updates require republishing. - **Performance considerations** - DLP policy evaluation adds processing time, VNet routing increases response times (10-50ms typically), large result sets require pagination, and rate limits are shared across Power Platform. ### Best 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 4. **Monitor usage** - track message consumption against limits 5. **Plan for scale** - design for multi-agent scenarios from the start 6. **Test extensively** - use Copilot Studio's testing framework ### Known issues and workarounds 1. **SSE not supported** - use Streamable HTTP for all implementations 2. **Tool naming conflicts** - prefix Tallyfy tools to avoid collisions with other MCP servers 3. **Large payloads** - implement pagination for result sets over 100 items 4. **Session timeout** - implement keep-alive mechanisms for long-running operations 5. **Regional latency** - deploy connectors in same region as Copilot Studio 6. **Resource rendering** - files and images in responses may need extra handling in custom UIs 7. **Admin center visibility** - MCP-enabled agents must be registered to appear in M365 admin center ### What's coming Microsoft keeps expanding this: wider GA coverage and more regions, Agent 365 as a unified control plane for AI agents, better debugging tools, more prebuilt enterprise connectors (GitHub, Asana, and Jira are already available), zero-trust architecture with full M365 admin governance, and performance improvements. Microsoft is a founding member of the Agentic AI Foundation, which signals continued commitment to MCP as an industry standard. [^1]: OAuth is the standard that lets you sign in to one app using another account, without sharing your password. - **[Using SSO with MCP servers](https://tallyfy.com/products/pro/integrations/mcp-server/sso-authentication/)**: SSO integration with MCP servers removes repeated authentication across AI tools. Users log in once with corporate credentials through providers like Azure AD or Okta, gaining access to all approved workflow integrations. ## Sign in once, use every AI tool If your company already uses single sign-on[^1] (SSO) - the "log in with your company account" button you see for email and other apps - your team can use that same login for Tallyfy's AI tools. Sign in once, and every approved tool just works. No separate password per tool. No secret keys to copy around. Here's why that matters. Say someone uses Tallyfy alongside their email, calendar, and a couple of other connected tools. Without SSO, each one is its own login. With SSO, it's one login your IT team controls. And they can switch it off in one place the day someone leaves. This is an advanced setup. Your IT team turns it on, usually with a developer's help. The technical details are further down this page. ### What you get - One company login across all approved AI tools (the same one people already use). - Central control for IT: approve tools, see who's connected, and cut off access when someone leaves. - Your existing security rules, like requiring a second step to log in, apply automatically. ### Which logins Tallyfy works with Tallyfy's AI connection works with the major company-login providers: - **Microsoft Entra ID** (formerly Azure AD) - **Okta** - **Google Workspace** - **OneLogin** and most other providers that follow the usual sign-in standards Setup differs a little for each one. Your IT team will find the specifics in the technical section below. ### A couple of honest limits - You'll sometimes still approve a tool the first time you connect it (one prompt per tool). - Logins from different providers don't always share a single sign-in behind the scenes, so some connections need their own setup. ## For your IT team *(Skip this unless you're setting up the technical side.)* ### What Tallyfy's MCP server already supports Tallyfy's MCP server already implements OAuth 2.1 with PKCE S256, Dynamic Client Registration (RFC 7591), and authorization server metadata discovery (RFC 8414). Tokens are RS256-signed JWTs with the public key at `/.well-known/jwks.json`. The well-known endpoint at `/.well-known/oauth-authorization-server` lets AI clients like ChatGPT and Claude Desktop discover OAuth endpoints automatically. Scopes use dot notation, for example `mcp.tasks.read`, `mcp.processes.write`, and `mcp.templates.read`. The server is listed on the [Official MCP Registry](https://registry.modelcontextprotocol.io/?q=tallyfy) as `com.tallyfy/mcp-server`. **Token resource binding (`mcp_resource` claim)** - Access tokens carry a canonical `mcp_resource` claim that pins the token to a specific MCP resource URL (the server endpoint it was issued for). The server uses this claim to detect and reject tokens replayed against a different resource. For backwards compatibility with legacy Passport-issued tokens (which use `aud: 1`), the server also accepts tokens that lack `mcp_resource` but present the expected legacy audience, so existing integrations keep working while new clients get the stricter binding. ### The authentication challenge in MCP MCP servers don't know who you are by default. They receive requests from AI agents with no identity or context. This creates gaps when accessing enterprise systems that need user credentials. Common workarounds and their problems: - Embedding API keys as environment variables - doesn't scale - OAuth Device Authorization Flow for local servers - clunky UX - Manual token management per tool - shadow IT risk and compliance headaches ### How SSO bridges the gap SSO integration with MCP uses OAuth 2.1 flows that delegate authentication to enterprise identity providers. #### The login flow, step by step 1. **User initiates connection** - AI agent requests access to a tool 2. **SSO redirect** - MCP server redirects user to corporate identity provider 3. **Corporate authentication** - user logs in with SSO credentials (including MFA) 4. **Token exchange** - identity provider returns an authorization code, which the MCP server exchanges for an access token 5. **API access** - MCP server uses the token to call service APIs This diagram shows how SSO authentication flows between users, AI agents, MCP servers, and identity providers. [Diagram removed for brevity] What to notice: - **Steps 4-5**: The identity provider validates corporate credentials including MFA and conditional access policies before issuing tokens - **Steps 8-9**: The MCP server handles token exchange automatically - users never see raw tokens - **Steps 10-13**: Once authenticated, the MCP server can make multiple API calls on behalf of the user without further prompts #### Accepting existing SSO tokens Advanced implementations let MCP servers accept existing SSO tokens directly: - AI client presents a valid OIDC ID token or access token from the identity provider - MCP server verifies token authenticity and extracts user permissions - Server performs token exchange to get service-specific API credentials - Already-authenticated users skip additional login prompts ### Which identity providers work, in detail #### Microsoft Entra ID (Azure AD) - 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 **Limitations:** Tokens are designed primarily for Microsoft APIs. No native cross-provider token exchange. Each MCP server must be registered as an app manually. #### Okta - OAuth 2.0 with device flow support - Custom authorization servers for API-specific scopes - Dynamic client registration and flexible token refresh - Okta Integration Network (OIN) listing for one-click deployment - SCIM provisioning for automated user management **Discovery:** Okta supports both `/.well-known/openid-configuration` and `/.well-known/oauth-authorization-server` (RFC 8414). The RFC 8414 endpoint is the standard for pure OAuth 2.0 flows. #### Google Workspace Identity - OAuth provider for Google services (Gmail, Drive, Calendar) and OIDC identity provider for third-party apps - Domain-wide delegation lets admins pre-authorize applications and service accounts - Admin-managed app whitelisting and Google Workspace Marketplace integration #### OneLogin and other providers Most enterprise identity providers offer SAML 2.0 and OIDC/OAuth 2.0 compatibility with similar token exchange limitations and marketplace integration options. ### Current gaps and challenges #### Repeated consent fatigue Users face multiple OAuth consent flows for each tool integration, even when using the same SSO credentials. An employee with email, calendar, Slack, GitHub, and Salesforce integrations hits five separate login prompts. #### Shadow OAuth visibility Token exchanges between AI applications and services often happen outside IT's oversight. There's no centralized view of which apps access which data for which users, making offboarding and access revocation difficult. #### Implementation complexity Each MCP server developer must implement OAuth components (authorization endpoints, token management, client registration). Building secure OAuth flows requires specialized knowledge, and mistakes introduce vulnerabilities. #### Token lifecycle management Coordinating token refresh, expiration, and revocation across multiple identity domains remains hard. There's no universal token exchange between providers, and revocation signals don't propagate consistently. ### Solution approaches #### Centralized profile system A cloud service acts as a universal integration broker, similar to [mcp.run's profile system](https://docs.mcp.run/blog/2025/05/14/mcp-sso/). Users connect tools once on a dashboard, group them into profiles, and AI applications request access to the whole profile through a single OAuth flow. The bridge service becomes the OAuth Authorization Server, storing encrypted API credentials in a token vault, routing MCP requests to appropriate services, and providing centralized audit logging. #### Enterprise IdP extensions An add-on for existing identity providers handles inter-application authorization. When an AI application needs a Slack token, it asks the mediation service, which validates the user's identity with the corporate IdP, checks admin policies, and returns the token, all without user interaction. This gives admins a dashboard for approving or denying AI-to-app connections with centralized policy enforcement and audit trails. #### Developer SDK approach Pre-built SDKs make OAuth manageable for MCP server developers by providing integrations for major identity providers, automatic token refresh, and consistent security patterns. ### Implementation strategies #### OAuth 2.1 standard compliance Tallyfy's MCP server already follows these OAuth 2.1 patterns. Here's what any MCP implementation needs: #### Security considerations **Token storage:** Use encrypted key vaults, short-lived access tokens with refresh mechanisms, and monitor for unusual API usage patterns. **Network security:** Require HTTPS for all authentication endpoints. Tallyfy's MCP OAuth endpoints include rate limiting - 5 registrations per hour for DCR, 60 token requests per minute. **Access control:** Map SSO roles to MCP tool permissions using scopes like `mcp.tasks.read` and `mcp.processes.write`. Support conditional access policies from identity providers. ### Best practices for enterprises #### Governance and compliance Define approved AI applications and integrations. Document data access requirements. Log all token exchanges and API access, and schedule regular permission audits. #### User experience optimization Minimize authentication friction by using existing SSO sessions. Group related tools into logical profiles. Support different client types - web apps use authorization code flow, desktop apps use device authorization flow, and CLI tools use client credentials or device flow. #### Technical architecture Cache tokens to reduce identity provider load. Implement circuit breakers for external API calls and design graceful degradation when identity services go down. ### Integration with popular providers #### Microsoft identity providers Register as an Enterprise Application in Azure AD Gallery. Use Entra ID authentication for Copilot Studio connectors - enterprise security controls apply automatically. #### Okta Integration Network Submit through OIN: create an integration in Okta's developer org, implement OIDC flow, add SCIM provisioning if applicable, then submit for certification. Okta customers get one-click configuration. #### Google Workspace Marketplace Requires OAuth application verification, privacy policy documentation, and minimal scope usage. Domain-wide installation gives admins centralized permission management. ### What's changing The OpenID Foundation is developing cross-domain authorization chaining standards. OAuth 2.0 extensions will enable more flexible cross-provider token exchange. AI-specific authentication protocols are also in development. The trend is moving toward user-controlled integration profiles that travel between AI applications, zero-trust architecture integration, and stronger audit trails for regulatory compliance. [^1]: Single sign-on. One company login (Entra ID, Okta, Google Workspace) unlocks every approved app, so people don't manage a password per tool. ### Claude anthropic - **[Run analytics with Claude](https://tallyfy.com/products/pro/integrations/mcp-server/claude-anthropic/analytics-with-claude/)**: Get real analytics from Tallyfy by asking Claude. Connect the Tallyfy MCP server, ask in plain English, and Claude reads your live workflow data and answers - often with a chart. This walkthrough covers a first hello-world query, the real questions worth asking next, and when to reach for full-dataset SQL. ## Your first analytics question, start to finish You can get real analytics out of Tallyfy just by asking Claude. Connect the [Tallyfy MCP server to Claude](/products/pro/integrations/mcp-server/claude-anthropic/), ask a question in plain English, and Claude reads your live workflow data and answers. Often with a chart you can drop straight into a document. This is the fast, conversational way to explore your data. No SQL, no dashboard to build. For the bigger question of when to ask Claude versus when to build a standing dashboard, see [one-time questions vs recurring dashboards](/products/pro/integrations/analytics/one-time-questions-vs-recurring-dashboards/). :::note[Example answers] The replies below show the *shape* of what Claude returns for a typical account, a small team running a dozen or so workflows. Your own numbers will be different. ::: ### Step 1: ask a hello-world question Once Claude is connected to your Tallyfy account, start small. Something you can eyeball to confirm it's reading the right data: ```text Connect to my Tallyfy account. How many templates do we have, what's the average number of steps per template, and can you show me a bar chart of templates by step count? ``` Claude calls the Tallyfy MCP server, pulls your templates, counts them, works out the average, and draws the chart. You might see something like: > You have 14 templates, averaging 9 steps each. Here's the spread. Your heaviest is your field-service process at 28 steps, then customer onboarding at 16. A few sit at 3 steps or fewer, like order intake and a simple approval, which often means they're really checklists rather than full processes. That's it. If the count matches what you expect, the connection is reading your data correctly and you can trust the harder questions. ### Step 2: ask the questions that actually matter Now ask the things you'd normally wait on a report for. Each of these is a one-time question. Ask, read, act, move on. - **Bottlenecks.** "Across our active processes, which step sits unfinished the longest on average?" - **Throughput.** "How many processes did we complete last month compared with the month before?" - **Cycle time.** "What's the average time from launch to completion for our Quotation process, and has it changed since we simplified it?" - **Adoption.** "Which templates were launched in the last 30 days, and which haven't been used at all?" Claude works through these in steps. It reads your data, counts, and usually double-checks itself before answering. When a question is vague (whose tasks? which date range?), it asks you to confirm before it touches anything. ### Step 3: reach for full-dataset SQL when you need it The Tallyfy MCP server answers through Tallyfy's API, which is plenty for most questions. When you need to query your entire history with custom SQL (joins across every task, form field, and run over several years), that's the job for [Tallyfy Analytics](/products/pro/integrations/analytics/). It copies your workflow data into a private Amazon Athena environment. You can point Claude at that data too. If you have the Analytics add-on, you already have the Athena credentials. Community MCP servers can run read-only SQL against Athena, so Claude writes the query, runs it, and explains the result in plain words. Search the MCP directories for "Athena", and see AWS Labs' official collection of AWS MCP servers[^1] for where this is heading. Keep any database connection read-only, and handle the credentials with the same care as any other system login. ### Tips for answers you can trust - **Ask Claude to show its work.** "List the templates you counted" turns a number into something you can verify. - **Save prompts you'll reuse.** If you ask the same question every month, word it the same way each time so the answer stays comparable. - **For numbers people depend on, lean on the governed dataset.** Exploring is Claude's strength. For figures that drive money or targets, Tallyfy Analytics gives you one definition computed the same way every time. [^1]: A growing set of official AWS connectors for AI assistants, including read-only query access to data services. [1] ### Vendors - **[ADP Run](https://tallyfy.com/products/pro/integrations/vendors/adp-run/)**: Tallyfy connects ADP Run's payroll and HR functions to your wider organization by automatically launching cross-department workflows for onboarding, offboarding, and role changes that coordinate IT, Facilities, Finance, and Training teams. ## What ADP Run can't do ADP Run handles payroll and basic HR for small businesses. But the moment someone's hired in ADP, manual coordination kicks in across systems that don't talk to each other. ADP Run can't tell IT to set up email accounts, notify Facilities to prepare a workspace, or trigger training enrollment. Teams end up chasing handoffs between separate portals. **What ADP Run covers:** - 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 - Multi-step approval workflows spanning teams - Real-time visibility into onboarding completion - Structured handoffs with clear ownership and deadlines ADP Run covers HR and payroll. But employee processes touch every department. Tallyfy runs 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 kicks off: - 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 makes sure: - IT access gets revoked on the correct date - Equipment return is tracked - Final payroll coordination happens on time ## 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 a 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. - **[ADP Workforce Now](https://tallyfy.com/products/pro/integrations/vendors/adp-workforce-now/)**: ADP Workforce Now handles HR and payroll but can't coordinate cross-department workflows triggered by employee events. Tallyfy launches structured processes across IT, Facilities, Finance, and Legal with clear ownership, deadlines, and escalation paths. ## What ADP Workforce Now can't do ADP Workforce Now covers HR, payroll, and talent management well. But when employee events happen - a hire, promotion, or termination - the coordination across departments still falls on people. It won't trigger IT provisioning when someone joins. It won't notify Facilities to set up a workspace. It can't route compensation approvals through multiple departments. Those handoffs happen through email and manual tracking. **What ADP handles:** - 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-team workflows spanning HR, Finance, and Legal - Real-time process visibility across the organization - Escalation when approvals stall ADP serves your HR team. Tallyfy coordinates workflows across ALL your teams. ## How Tallyfy fills this gap When an ADP event fires, Tallyfy launches a structured workflow with clear ownership, deadlines, and escalation paths. ### Enterprise onboarding When ADP records a new hire, Tallyfy kicks off: - 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 a 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 Tallyfy. - **[Automation Anywhere](https://tallyfy.com/products/pro/integrations/vendors/automation-anywhere/)**: Tallyfy connects Automation Anywhere bots with human workflows, providing visibility and accountability for every step. When bots finish tasks, human activities like approvals and exception handling get tracked and routed properly. ## Where Automation Anywhere stops short Automation Anywhere is great at automating repetitive digital tasks. But business processes don't end when a bot finishes - they continue with human activities that Automation Anywhere can't coordinate. When a bot processes a purchase order, it still needs human approval. When it extracts data from emails, someone has 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:** - Visibility across automated and manual steps - Accountability for end-to-end process outcomes - Human judgment steps inside automated flows - SLA tracking that spans bots and people - Exception escalation to the right reviewers Automation Anywhere automates tasks. Tallyfy manages the full process - connecting bot work with human work through visibility and accountability. ## How Tallyfy fills this gap Tallyfy acts as the coordination layer between Automation Anywhere bots and human workflows. ### Full process visibility When Automation Anywhere bots run, Tallyfy provides: - Real-time status across all steps - automated and manual - A single dashboard showing bot completion and human task progress - Process-level metrics combining bot and human performance - An audit trail spanning the entire process ### Accountability for every step Tallyfy makes sure nothing gets missed: - Every human step has an owner and deadline - Exceptions automatically route to the right reviewers - Escalation rules prevent stalled processes - Completion tracking across all participants ### Intelligent routing When bots hit edge cases, Tallyfy handles: - Classifying exception types - Routing to the right human reviewers - Assigning priority based on business impact - Returning 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 setups. **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 connecting Automation Anywhere with your Tallyfy workflows. We'll map your processes and find where human-bot coordination adds the most value. - **[BambooHR](https://tallyfy.com/products/pro/integrations/vendors/bamboohr/)**: Tallyfy extends BambooHR beyond basic HR admin by launching cross-department workflows for onboarding, offboarding, and promotions. IT, Facilities, and Finance teams get coordinated tasks with deadlines and escalation instead of manual emails. ## The gap BambooHR can't fill BambooHR stores employee data and handles basic HR admin. But it hits an automation ceiling - it can't coordinate the cross-department work that employee changes trigger. When someone's hired in BambooHR, the system knows their name, department, and start date. It can't tell IT to provision a laptop, notify Facilities to prepare a desk, or schedule orientation. 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 approvals beyond basic manager sign-off - Visibility into onboarding completion across teams - Conditional routing based on role, location, or department - Escalation when tasks are overdue BambooHR serves your HR team. Employee processes span every department. Tallyfy coordinates 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 kicks off: - IT equipment provisioning and account setup - Facilities workspace and access card preparation - Training schedule based on role and department - Finance expense account and payroll validation - Manager introductions and team onboarding 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 - Announcements 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 a 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 code examples and webhook handling details, 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 coordinates handoffs, exception handling, and governance between Blue Prism's bot automation and human workflows, bringing both digital and human workers into a single process. ## What Blue Prism doesn't cover Blue Prism's digital workforce handles complex automation with strong governance. But even the best bots can't handle every scenario - human judgment is still needed for exceptions, approvals, and edge cases. When a Blue Prism bot processes loan applications, edge cases need human review. When it reconciles accounts, discrepancies require investigation. When it processes claims, complex cases need underwriter judgment. Blue Prism manages bots - not the humans who work alongside them. **What Blue Prism automates:** - Digital workforce management at scale - Multi-step automation sequences - Secure credential management - Compliance logging for bot activities **What falls through the cracks:** - Governance over combined human-bot processes - Coordination between bots and human teams - Exception workflows that need human judgment - Full process accountability spanning both sides - Changing human steps without code changes - SLA tracking across the entire human-bot workflow Blue Prism governs digital workers. Tallyfy coordinates those digital workers WITH human workers in unified, governed processes. ## How Tallyfy fills this gap Tallyfy connects Blue Prism with human workflows, extending governance across your entire process. ### Extended governance When Blue Prism bots run, Tallyfy extends governance to: - Human activities that follow bot work - Exception handling procedures - Approval workflows triggered by bot outputs - Audit trails spanning bots and humans ### Bot-human coordination Tallyfy manages handoffs between bots and people: - Bot completes task - Tallyfy assigns human review - Human approves - Tallyfy triggers the next bot - Full accountability chain maintained throughout ### Exception handling When bots hit exceptions: - Tallyfy receives notifications via webhook - Routes to the right human specialist based on exception type - Tracks resolution time and method - Sends data back to Blue Prism when it's ready to resume ## Connect today **Blue Prism API**: Trigger bots from Tallyfy and receive completion notifications. **Middleware**: Connect via [Workato](/products/pro/integrations/middleware/workato/) or other integration platforms. **API**: Use [Tallyfy's API](/products/pro/integrations/open-api/) to run workflows that span Blue Prism bots 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 connecting Blue Prism with your Tallyfy workflows. We'll help you extend governance across your human-bot processes. - **[Copper](https://tallyfy.com/products/pro/integrations/vendors/copper/)**: Tallyfy works alongside Copper CRM to coordinate cross-team tasks and structured workflows, like approvals and post-sale handoffs, that Copper's Google Workspace-based relationship tracking and pipeline management can't handle alone. ## What Copper doesn't cover Copper lives inside Google Workspace - it's a CRM that works directly in Gmail and Google Calendar. It captures relationship data automatically. That's great. But deals need more than relationship tracking - they need coordinated tasks across teams. When a deal moves forward in Copper, the actual work involves multiple people: solutions architects scoping requirements, finance approving pricing, legal reviewing contracts. Copper captures emails and calendar events - not the structured task sequences that push deals to close. **What Copper handles:** - 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 coordinates the work that happens across your organization. ## How Tallyfy fills this gap Tallyfy connects Copper deal changes with the detailed workflows that need to 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 - Gives everyone involved real-time visibility ### 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 coordination When deals close in Copper, Tallyfy kicks off: - 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 a 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/)**: Tallyfy connects Freshdesk ticket tracking with structured multi-team workflows. Launch processes with assigned tasks, deadlines, and approval chains that turn conversation threads into accountable cross-department coordination. ## What Freshdesk can't do Freshdesk handles ticket management, automations, and knowledge bases well. But tickets are unstructured - they capture conversations, not the multi-step workflows you need to actually resolve complex issues. When a ticket needs engineering investigation, management approval, or cross-department coordination, it turns into a conversation thread. Freshdesk tracks what was discussed. It doesn't manage the work that needs to happen. **What Freshdesk covers:** - Ticket creation and assignment - SLA tracking and automation - Customer communication - Agent productivity metrics **What's missing:** - Multi-team resolution workflows - Approval chains for exceptions - Structured data collection at each step - Post-ticket follow-up processes - Cross-department handoffs with accountability Freshdesk organizes your support queue. Tallyfy structures the work that actually resolves complex tickets. ## How Tallyfy fills the gap Tallyfy acts as the coordination layer between Freshdesk tickets and 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 - Sends results back to the support team ### Exception handling When tickets need special handling, Tallyfy: - Routes approval requests to the right managers - Handles multi-level approval chains - Documents decision history - Enforces compliance requirements ### Improvement workflows When patterns emerge from tickets, Tallyfy runs: - Root cause analysis workflows - Bug tracking processes - Documentation update workflows - Training needs identification ## Connect today **Middleware**: Connect through [Zapier](/products/pro/integrations/middleware/zapier/) or [Make](/products/pro/integrations/middleware/make/) to trigger Tallyfy workflows from Freshdesk events. **API**: Build a 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 automatically launches cross-department workflows for IT, equipment, training, and finance whenever employee events like new hires or terminations happen in Gusto. ## The gap Gusto can't fill Gusto handles payroll, benefits, and HR for small and mid-sized businesses, but it can't coordinate the IT provisioning, training, or facilities setup that new hires actually need. When someone's hired in Gusto, payroll and benefits get processed. But nobody in IT gets told to create an email account. Orientation doesn't get scheduled. Expense access doesn't get set up. These tasks live in separate systems and depend on 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 - Cross-department coordination for Facilities and Training - Timesheet exceptions and complex shift handling - Structured workflows beyond basic onboarding checklists Gusto covers HR and payroll. But employee processes span every department. Tallyfy runs workflows across all your teams - not just one. ## How Tallyfy fills this gap When a Gusto employee event fires, like a hire, termination, or status change, Tallyfy launches a structured workflow that coordinates every downstream team. ### Employee onboarding When Gusto records a new hire, Tallyfy kicks off: - 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 a 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/)**: Help Scout excels at personal email-like customer conversations but can't track the structured multi-step work across teams needed to actually resolve issues. Tallyfy fills that gap by launching accountable workflows and coordinating cross-department tasks triggered from Help Scout conversations via middleware or API. ## Where Help Scout stops and Tallyfy starts Help Scout makes support feel personal - conversations that read like email, not tickets. Customers love it. But every helpdesk tool shares the same blind spot: conversations capture what people said, not the work that needs to happen next. When a Help Scout thread needs product input, an engineering fix, or sign-off from three departments, the conversation records the discussion. It doesn't track the multi-step work required to actually resolve the issue. **What Help Scout handles well:** - Email-like customer conversations - Shared inboxes with collision detection - Knowledge base (Docs) - Customer profiles and history **What slips through:** - Structured workflows triggered by conversations - Cross-team coordination with clear accountability - Internal process kicks from customer needs - Follow-up sequences after the conversation closes - Root cause analysis processes Help Scout keeps support human. Tallyfy structures the behind-the-scenes work that actually gets issues resolved. ## How Tallyfy fills this gap Tallyfy connects Help Scout conversations to the structured workflows that drive full resolution. ### Beyond the inbox When conversations need action, Tallyfy: - Launches structured task workflows - Assigns work to teams outside support - Tracks completion with deadlines - Shows resolution progress in real time ### Cross-team coordination When conversations involve multiple departments, Tallyfy: - Routes tasks to the right teams - Runs parallel work streams - Rolls updates back to support - Keeps nothing from falling through cracks ### Continuous improvement When patterns surface from conversations, Tallyfy runs: - Bug report workflows with engineering - Feature request evaluation processes - Documentation update workflows - Training and onboarding refreshes ## Connect today **Middleware**: Connect through [Zapier](/products/pro/integrations/middleware/zapier/) or [Make](/products/pro/integrations/middleware/make/) to trigger Tallyfy workflows from Help Scout events. **API**: Build a custom connection using [Tallyfy's API](/products/pro/integrations/open-api/) alongside 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 talk about connecting Help Scout with your Tallyfy workflows. - **[Close](https://tallyfy.com/products/pro/integrations/vendors/close/)**: Tallyfy pairs with Close CRM to handle cross-team tasks and handoffs between sales calls and deal stages. From demo coordination to pricing approvals and onboarding, it keeps supporting work on pace with fast-moving reps. ## What Close can't do on its own Close is great for inside sales - calling, email sequences, and pipeline tracking for fast-moving teams. But between calls and stage changes, tasks pile up that Close can't coordinate. A rep logs a qualifying call. Now what? Someone needs to schedule a demo with a solutions engineer. Pricing needs approval. Legal has to review custom terms. Close tracks the deal and comms - not the multi-person work that actually moves deals forward. **What Close handles:** - Built-in calling and SMS - Email sequences and tracking - Pipeline and deal management **What falls through:** - Tasks between calls and meetings - Cross-team coordination for demos and proposals - Pricing exception approvals - Post-call follow-up assignments - Handoffs to Operations after close Close helps reps work fast. Tallyfy makes sure the supporting work across your org keeps pace. ## How Tallyfy fills this gap Tallyfy connects Close activities with the workflows that support each deal - so nothing gets dropped between stages. ### Call follow-up workflows After calls logged in Close, Tallyfy: - Launches follow-up task sequences - Assigns prep work to the right team members - Tracks completion before the next touchpoint - Escalates overdue tasks automatically ### 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, Tallyfy kicks off: - Handoff to Customer Success - Account setup and provisioning - Onboarding tasks - Training scheduling ## Connect today **Middleware**: Connect via [Zapier](/products/pro/integrations/middleware/zapier/) to trigger Tallyfy workflows from Close events. **API**: Build a 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. - **[HiBob](https://tallyfy.com/products/pro/integrations/vendors/hibob/)**: Tallyfy extends HiBob by coordinating the cross-department workflows that HR events trigger, launching structured processes across IT and facilities and finance and training teams whenever a new hire or role change or departure happens in Bob. ## What HiBob can't coordinate on its own HiBob (Bob) is great at modern HR - clean interfaces, employee self-service, and automation inside the HR department. But people processes don't stop at HR. When someone joins in Bob, the HR system handles onboarding paperwork. IT still needs to provision accounts and equipment. Facilities needs to prepare a workspace. Finance needs to set up expense access. Bob can't coordinate all those teams at once. **What HiBob handles well:** - Employee self-service and HR records - Time-off management and approvals - Performance cycles and reviews **What falls through the cracks:** - Cross-department coordination after HR events - IT provisioning and access management - Equipment ordering and delivery tracking - Multi-team approval chains - External vendor and contractor workflows Bob serves your HR team well. But employee processes span every department - and Tallyfy coordinates workflows across all your teams, not just one. ## How Tallyfy fills this gap When a HiBob 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 kicks off: - 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 a 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. - **[HubSpot](https://tallyfy.com/products/pro/integrations/vendors/hubspot/)**: Tallyfy works alongside HubSpot by managing the hidden micro-tasks and cross-team handoffs that happen between CRM pipeline stage changes, from marketing-to-sales transitions through deal execution and post-sale customer onboarding workflows. ## The gap HubSpot can't fill HubSpot tracks deals through pipeline stages and connects marketing with sales. But it misses the dozens of micro-tasks that need to happen between each stage change and during marketing-to-sales handoffs. When a lead goes from marketing qualified to sales qualified in HubSpot, it looks like a single status flip. In reality, it needs research, discovery call scheduling, talking point prep, and contact mapping. Each step involves multiple people, deadlines, and conditional logic. HubSpot's workflows can send emails - but they can't coordinate tasks across teams. **What HubSpot handles:** - Marketing automation and lead scoring - Deal pipeline and stages - Customer communications - Reporting and analytics **What falls through the cracks:** - Micro-tasks between sales stages - Marketing-to-sales handoff coordination - Cross-team task assignment with accountability - Conditional workflows across multiple departments - Post-sale onboarding across Operations and Success teams - Audit trails for deal execution HubSpot shows a lead became an opportunity. Tallyfy makes sure every micro-task behind that transition actually gets done. ## How Tallyfy fills this gap Tallyfy connects HubSpot pipeline changes with the detailed workflows that need to happen between them. ### Marketing-to-sales handoffs When leads qualify in HubSpot, Tallyfy: - Launches structured handoff workflows - Makes sure research and prep tasks finish before the 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 involved parties ### Customer onboarding When deals close in HubSpot, Tallyfy runs: - 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 a 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 drive deal success. - **[Intercom](https://tallyfy.com/products/pro/integrations/vendors/intercom/)**: Tallyfy connects Intercom's conversational support to structured workflows that resolve customer issues. Launch trackable processes with deadlines and ownership when chats need follow-up like bug fixes, feature requests, or success handoffs. ## What Intercom can't do Intercom is great at conversational support - live chat, bots, and messaging that feel natural. But conversations are unstructured by nature. They capture what customers say, not the work needed to act on it. When a chat reveals a bug, requires a product change, or needs engineering input, the thread captures the discussion. It doesn't coordinate the multi-team work that actually resolves the customer's problem. **What Intercom handles:** - Live chat and messaging - Bot-driven support automation - Customer data and segments - Conversation history **What it doesn't cover:** - Structured workflows triggered by conversation insights - Multi-team coordination beyond chat - Post-conversation follow-up with deadlines - Feature request tracking with accountability - Customer success handoffs with clear ownership Intercom manages the conversation. Tallyfy manages the work that follows. ## How Tallyfy fills the gap Tallyfy connects Intercom conversations to the structured workflows that deliver on customer needs. ### From conversation to action When chats need follow-up, Tallyfy: - Launches structured task workflows - Assigns work to the right teams - Tracks completion with deadlines - Sends status updates back to support ### Customer success workflows When conversations reveal opportunities, Tallyfy: - Triggers onboarding check-in processes - Coordinates feature adoption campaigns - Routes expansion opportunities to sales ### Product feedback loops When conversations surface feature requests, Tallyfy runs: - 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 a 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. - **[Insperity](https://tallyfy.com/products/pro/integrations/vendors/insperity/)**: Tallyfy coordinates the cross-department workflows that Insperity's PEO and HR outsourcing services don't cover, automatically launching IT provisioning and facilities setup and training enrollment and equipment tracking across every team whenever employee events like new hires or terminations occur in Insperity. ## The gap Insperity can't fill Insperity provides full-service PEO with HR outsourcing for SMBs - but it's focused on HR administration, not coordinating the business processes that employee events trigger across your organization. When Insperity processes a new hire, they handle paperwork and benefits enrollment. But IT needs to create accounts. Facilities needs workspace setup. Training needs to schedule orientation. None of that is Insperity's job. **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-team approval workflows - Real-time visibility into process completion Insperity handles HR outsourcing. Business processes span every department. Tallyfy coordinates 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 workflow that coordinates all downstream teams outside the PEO relationship. ### Employee onboarding When Insperity records a new hire, Tallyfy kicks off: - 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 a 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. - **[Jira Service Management](https://tallyfy.com/products/pro/integrations/vendors/jira-service-management/)**: Tallyfy extends Jira Service Management beyond IT by coordinating the cross-department business workflows and non-technical team handoffs that JSM tickets often trigger but can't track on its own. ## The gap Jira Service Management can't fill Jira Service Management connects IT support with development through Jira. When tickets need engineering work, the handoff is smooth. But many service requests need 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 handles the IT-to-Dev flow. It doesn't cover the broader business workflows that service requests often kick off. **What Jira Service Management handles:** - 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 JSM bridges IT and Development. Tallyfy bridges IT with the rest of your business. ## How Tallyfy fills this gap Tallyfy acts as the coordination 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 sign-off, Tallyfy: - Routes to the right business approvers - Handles multi-level approval chains - Documents approval history - Enforces compliance requirements ### Operational handoffs When IT service delivery triggers business action, Tallyfy coordinates: - New employee equipment and access setup - Vendor onboarding coordination - Security compliance workflows - Business continuity procedures ## Connect today **Middleware**: Connect through [Zapier](/products/pro/integrations/middleware/zapier/) or [Make](/products/pro/integrations/middleware/make/) to trigger Tallyfy workflows from JSM events. **API**: Build a 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. - **[Justworks](https://tallyfy.com/products/pro/integrations/vendors/justworks/)**: Tallyfy coordinates the cross-department workflows that Justworks can't cover. Employee events like hiring and offboarding trigger work across IT, facilities, training, and finance that goes beyond HR and payroll. ## The gap Justworks can't fill Justworks handles payroll, benefits, and compliance for growing companies. But when employee events happen, coordinating work across departments beyond HR still requires manual effort. A new hire triggers paperwork and benefits in Justworks - but IT needs to provision accounts, facilities needs to prep a workspace, training needs to schedule sessions, and finance needs to set up expense access. Those handoffs happen outside Justworks entirely. **What Justworks manages:** - Payroll processing and PEO services - Benefits administration and compliance - HR support and employee records - Time-off tracking **What falls through the cracks:** - Cross-department coordination beyond HR - IT provisioning and system access - Equipment ordering and delivery tracking - Multi-step approval workflows - Visibility into onboarding completion Justworks covers HR and payroll. Tallyfy coordinates workflows across every other team involved. ## How Tallyfy fills this gap When an employee event fires in Justworks - 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 kicks off: - IT account setup and equipment provisioning - Facilities workspace and access prep - 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 the 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 a 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. - **[Loom](https://tallyfy.com/products/pro/integrations/vendors/loom/)**: Turn Loom training videos and feedback recordings into structured Tallyfy workflows with acknowledgment tracking, deadline enforcement, and clear task ownership. ## The gap Loom can't fill Loom changed async video communication. But videos are conversations, not processes. Watching a video doesn't guarantee anything actually happened. Someone records a training video in Loom. It gets watched (maybe). But who confirmed they understood it? What tasks came out of it? When someone shares feedback via Loom, does the recipient have a deadline? Is anyone held accountable? There's a real gap between video communication and actual execution. **What Loom handles:** - Video recording and sharing - View tracking and analytics - Comments and reactions - Video 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 records for training completion Loom is great for video communication. But communication alone doesn't drive action. Tallyfy turns video content into trackable workflows with clear ownership. ## How Tallyfy fills this gap When you share a Loom video for training, feedback, or updates, Tallyfy launches a structured workflow that turns communication into completed work. ### Training workflows When training videos are shared, Tallyfy runs: - 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**: Set up Slack or email integrations to detect Loom URLs and trigger the right workflows. **API**: Build a custom integration using [Tallyfy's API](/products/pro/integrations/open-api/) with the Loom SDK for embedded recording. ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss connecting Loom with your Tallyfy workflows. - **[Kofax](https://tallyfy.com/products/pro/integrations/vendors/kofax/)**: Tallyfy coordinates the human review and approval workflows that follow Kofax document capture and data extraction. It routes low-confidence results to specialists and manages multi-level approvals and cross-department tasks across the full document lifecycle. ## The gap Kofax can't fill Kofax is great at document capture and process automation - pulling data from invoices, forms, and documents with high accuracy. But documents don't exist in isolation. They're part of broader business processes that need 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? Kofax handles capture and extraction - the human workflows around those documents need separate coordination. **What Kofax automates:** - 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 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 Kofax captures and extracts. Tallyfy coordinates the human activities, approvals, and follow-up actions that turn captured documents into completed business processes. ## How Tallyfy fills this gap Tallyfy connects Kofax document processing with the human workflows that follow. ### Document workflow coordination 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 - Tracks the document through its full lifecycle ### Human review integration Tallyfy manages document review: - Kofax flags extraction for review - Tallyfy assigns to a specialist - Reviewer corrects or approves - Tallyfy triggers next steps - High-confidence extractions skip review and proceed automatically - Full audit trail of all decisions ### Post-capture workflows After Kofax extracts document data, Tallyfy handles: - 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's 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 finishes 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 connecting Kofax with your Tallyfy workflows. We'll help you coordinate document capture with human review and approval processes. - **[Namely](https://tallyfy.com/products/pro/integrations/vendors/namely/)**: Tallyfy extends Namely's mid-market HR capabilities by automating the cross-department workflows that follow HR events like new hires and role changes. It coordinates IT provisioning, facilities setup, and training schedules across every team involved. ## Where Namely stops and manual work begins Namely covers mid-market HR well - HRIS, payroll, benefits, and talent management. But when an HR event needs action from multiple departments, you're back to emails and spreadsheets. A new hire in Namely triggers paperwork. IT still needs to set up accounts. Facilities needs to prepare a workspace. Training needs to book orientation. None of that coordination lives inside Namely. **What Namely handles:** - Employee records and HRIS - Payroll and benefits - Talent management and reviews - Time-off tracking **What it doesn't:** - Cross-department coordination - IT provisioning and access management - Equipment ordering and tracking - Multi-team approval chains - Vendor and contractor workflows Namely covers HR. Tallyfy coordinates the workflows that touch every other team. ## How Tallyfy picks up the slack When a Namely event fires - hire, role change, departure - Tallyfy kicks off a structured workflow that reaches every team involved. ### Employee onboarding When Namely records a new hire, Tallyfy runs: - 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 a 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 connects NetSuite's financial record-keeping with cross-department human coordination. It handles invoice approvals, vendor onboarding, and month-end close workflows that span AP managers, legal teams, and compliance across your organization. ## The gap NetSuite can't fill NetSuite is your financial system of record - but its workflows operate on single records. It can't coordinate an invoice approval that spans Accounts Payable, a department manager, and the CFO in sequence. Each approval has to be a separate workflow. NetSuite records transactions. It doesn't handle the human decisions around them. Who reviews the expense? Who approves the PO? Who verifies vendor compliance before the first payment? That coordination happens 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:** - Approval chains that span multiple 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 NetSuite serves your Finance team. But financial processes need coordination across Sales, Operations, Legal, and Compliance. Tallyfy runs 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 everyone involved. Every approval gets an owner, a deadline, and escalation if someone doesn't respond. ### Invoice approvals When NetSuite receives an invoice, Tallyfy handles: - 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 manages: - 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 built for ERP integration. **API**: Build a custom integration using [Tallyfy's API](/products/pro/integrations/open-api/) with NetSuite's REST APIs or SuiteScript. For 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 Tallyfy. We'll map your approval chains and identify processes that need cross-department coordination. - **[Paychex](https://tallyfy.com/products/pro/integrations/vendors/paychex/)**: Tallyfy extends Paychex Flex beyond payroll and HR by launching cross-department workflows when employee events occur. It coordinates onboarding, payroll, and offboarding across IT, Facilities, and Training teams. ## The gap Paychex can't fill Paychex Flex handles payroll, HR, and benefits administration. But the moment payroll runs or an employee status changes, coordination across departments still requires manual work. Paychex can't set up IT accounts when someone's hired. It can't coordinate Facilities for workspace prep. It can't route approval workflows for overtime exceptions or compensation changes. These cross-system handoffs end up in email chains and spreadsheets. **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 covers HR and payroll. But employee processes span every department. Tallyfy coordinates 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 coordinates: - 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 a 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. - **[Paylocity](https://tallyfy.com/products/pro/integrations/vendors/paylocity/)**: Tallyfy picks up where Paylocity stops by coordinating the cross-department workflows that employee events trigger, like IT provisioning, facilities setup, training enrollment, and offboarding tasks, across every team in the employee lifecycle. ## The gap Paylocity can't fill Paylocity manages employee records and processes payroll. But the moment someone's hired, a wave of manual coordination begins that Paylocity doesn't handle. Paylocity can't tell IT to order a laptop. It can't assign desk setup to Facilities, 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 - Visibility into process completion across departments - Structured handoffs with clear ownership and deadlines - Compliance tracking for certifications and training Paylocity serves your HR team. But employee lifecycle processes span every department - IT, Facilities, Training, Finance, and Legal. Tallyfy coordinates 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. Each step has an owner, a deadline, and escalation rules if something stalls. ### Employee onboarding When Paylocity records a new hire, Tallyfy coordinates: - 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 the 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 a custom integration using [Tallyfy's API](/products/pro/integrations/open-api/) with Paylocity's REST APIs and webhooks. For technical 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 find the best automation opportunities. - **[Paycom](https://tallyfy.com/products/pro/integrations/vendors/paycom/)**: Tallyfy extends Paycom's single-database HCM platform to the cross-department workflows it can't reach. It coordinates IT provisioning, facilities setup, training, and finance tasks when employee events like new hires or role changes occur. ## The gap Paycom can't fill Paycom gives you 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 centralizes HR data, but IT still needs separate notifications for account provisioning. Facilities needs alerts for workspace setup. Training needs to coordinate schedules. These 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 platform - Equipment ordering and delivery tracking - Multi-team approval chains - External vendor and contractor workflows Paycom centralizes your HR data. Business processes span every department. Tallyfy coordinates 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 coordinates: - 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 a 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. - **[Power Automate Desktop](https://tallyfy.com/products/pro/integrations/vendors/power-automate-desktop/)**: Tallyfy connects Power Automate Desktop's local RPA tasks with human activities and cloud processes. It manages handoffs, exception routing, and end-to-end tracking across all automated and manual steps. ## The gap Power Automate Desktop can't fill Power Automate Desktop (PAD) brings RPA to every Windows user - automating clicks, keystrokes, and legacy app 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. Who verifies data after PAD enters it into a legacy system? Who reviews extracted output? Who resolves errors? PAD automates desktop tasks - it can't coordinate the broader processes those tasks belong to. **What PAD automates:** - Legacy desktop application interaction - UI-based data entry and extraction - Local file and folder operations - Windows automation tasks **What falls through the cracks:** - Coordinating desktop automation with 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 PAD automates what happens on desktops. Tallyfy coordinates the full process - connecting desktop automation with human activities, cloud services, and cross-department workflows. ## How Tallyfy fills this gap Tallyfy acts as the coordination layer connecting Power Automate Desktop with human workflows and cloud-based processes. ### Process coordination When PAD flows run, 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 the right reviewers ### Human - automation handoffs Tallyfy manages smooth transitions: - Human completes preparation task → Tallyfy triggers PAD flow - PAD flow completes → Tallyfy assigns verification task - Human approves → process moves to next stage - Full audit trail maintained throughout ### Exception management When PAD hits errors: - Tallyfy gets notified via Power Automate cloud flow - Routes to a human troubleshooter with context - Tracks resolution and outcome - Restarts automation when it's 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 connecting Power Automate Desktop with your Tallyfy workflows. - **[Pipedrive](https://tallyfy.com/products/pro/integrations/vendors/pipedrive/)**: Tallyfy works alongside Pipedrive by managing cross-team tasks and approval workflows between deal stage changes. It handles proposal reviews, contract approvals, and post-win handoffs that Pipedrive's visual pipeline can't coordinate on its own. ## The gap Pipedrive can't fill Pipedrive gives sales teams a visual pipeline to track deals. But moving a deal from one stage to the next takes more than dragging a card - it requires coordinated tasks across multiple people that Pipedrive can't manage. When a deal moves to "Proposal Sent," 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 actually gets created, reviewed, and approved correctly. ## How Tallyfy fills this gap Tallyfy acts as the coordination layer connecting 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 handles: - Customer onboarding handoff - Win review documentation - 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 a 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. - **[QuickBooks Payroll](https://tallyfy.com/products/pro/integrations/vendors/quickbooks-payroll/)**: Tallyfy coordinates cross-department workflows that QuickBooks Payroll can't handle alone, like timesheet approvals, exception routing, new hire IT provisioning, and accounting reconciliation. ## The gap QuickBooks Payroll can't fill QuickBooks Payroll handles payroll processing and integrates with QuickBooks accounting. But every payroll event triggers downstream coordination that QuickBooks can't manage. Timesheets need verifying before processing. Exceptions need routing through approval chains. Accounting needs reconciliation tasks. New hires need IT provisioning, equipment, and training. These cross-department handoffs all 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 coordinates 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 coordinates: - 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 a custom integration using [Tallyfy's API](/products/pro/integrations/open-api/) with the QuickBooks Payroll API. ## Get started [Book a consultation](https://tallyfy.com/booking/) to discuss connecting QuickBooks Payroll with your Tallyfy workflows. - **[Rippling](https://tallyfy.com/products/pro/integrations/vendors/rippling/)**: Tallyfy extends Rippling's HR/IT/Finance platform by coordinating complex approval chains and compliance workflows. It handles external vendors, contractors, and cross-department processes that Rippling's if-then automation can't cover. ## The gap Rippling can't fill Rippling unifies HR, IT, and Finance on one platform with strong internal automation. But enterprise approval hierarchies and regulatory compliance workflows need coordination that goes beyond Rippling's platform. Rippling's if-then automation handles simple triggers well. Complex multi-conditional workflows - where approval routing depends on salary thresholds AND manager level AND department AND budget availability - need heavy configuration. Workflows involving external vendors, contractors, or compliance partners require coordination 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 - Cross-team workflows that span outside Rippling's platform - 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 coordinates workflows across all your people - 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 people 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 coordinates: - Policy rollout 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 a 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 coordinates the micro-tasks, cross-team handoffs, and deadline-driven workflows between Salesforce pipeline stages that determine whether deals succeed. ## The gap Salesforce can't fill Salesforce tracks your deals through pipeline stages - Lead, Qualified, Proposal, Negotiation, Closed Won. But it misses the dozens of micro-tasks that must happen between each stage transition. When a deal moves from "Qualified" to "Proposal," 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 prep. Each involves multiple people, deadlines, and conditional logic. Salesforce can't track any of it. **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 Salesforce stage can have completely different outcomes. The difference? How well the micro-tasks between stages get executed. Tallyfy makes those invisible tasks visible, trackable, and automatic. ## How Tallyfy fills this gap Tallyfy acts as the coordination layer between Salesforce stage changes and the detailed workflows that must happen between them. ### Micro-task coordination 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 involved teams ### Cross-team handoffs Tallyfy handles handoffs Salesforce can't: - Sales qualifies deal → Technical team scopes requirements - Pricing approved → Legal reviews contract terms - Deal closed → Operations begins onboarding - Full visibility across every team ### Post-sale workflows When deals close in Salesforce, Tallyfy kicks off: - 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 a 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. - **[Slack](https://tallyfy.com/products/pro/integrations/vendors/slack/)**: Tallyfy's native Slack integration turns chat messages into tracked tasks and workflows with ownership and deadlines, so action items don't get buried in busy channels. ## The gap Slack can't fill Slack is where your team communicates. But communication isn't process. When someone asks "can you approve this?" in Slack, there's no owner, no deadline, no escalation. If the message gets buried in a busy channel, the work doesn't happen. Slack can't track whether a request was completed or who's responsible. **What Slack handles:** - Real-time messaging - Channel-based conversations - File sharing and search - Video calls and huddles **What falls through the cracks:** - Request tracking with ownership and deadlines - Approval workflows with 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. 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 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. - **[ServiceNow](https://tallyfy.com/products/pro/integrations/vendors/servicenow/)**: Tallyfy works alongside ServiceNow by handling the cross-department business processes that IT events trigger, like procurement actions or HR coordination. Non-IT teams can complete their tasks without needing expensive ServiceNow licenses or ITSM complexity. ## The gap ServiceNow can't 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 needs procurement action, HR involvement, or facilities coordination - you've got two bad options. Force everyone into ServiceNow (expensive, complex) or lose visibility when work leaves IT. **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 coordinates the business processes that IT events trigger across your organization. ## How Tallyfy fills this gap Tallyfy 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 handles: - 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 a 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. - **[Square Payroll](https://tallyfy.com/products/pro/integrations/vendors/square-payroll/)**: Tallyfy coordinates cross-department workflows that Square Payroll can't handle on its own. It launches structured processes for IT provisioning, training, and finance setup whenever payroll events like new hires or terminations occur. ## The gap Square Payroll can't fill Square Payroll integrates tightly with Square's point-of-sale and payment platform. But Square's merchant focus means cross-department coordination still requires manual work. When Square Payroll processes a new hire, they appear in the Square system. IT still needs to provision accounts beyond Square. Training needs to schedule orientation. Finance needs expense setup. Those handoffs happen outside Square's platform entirely. **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 its own platform, but employee processes span every department. Tallyfy coordinates 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 Square's platform. ### Employee onboarding When Square records a new hire, Tallyfy kicks off: - 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 a 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 not structured process execution. Tallyfy fills that gap by turning chat messages into tracked workflows with assigned owners, deadlines, escalation rules, and audit trails. ## The gap Teams can't fill Microsoft Teams is where your team communicates. But communication isn't process. When someone asks "can you approve this?" in a Teams message, there's no assigned owner, no deadline, no escalation. If that message gets buried in a busy channel, the work simply doesn't happen. Teams can't track whether a request was completed or hold anyone accountable. Teams Approvals (built on Power Automate) handles simple linear approvals - but it can't manage 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 - Multi-department approval workflows - SLA enforcement and automatic escalation - Process visibility and completion metrics - Conditional routing based on request type or data - Audit trails for compliance Teams is where people talk. Tallyfy is where work gets tracked and done. ## How Tallyfy fills this gap When a request comes in through Teams, Tallyfy creates a structured workflow with assigned owners, deadlines, and escalation rules. Tallyfy tracks every step - 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 Pair 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 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 coordinates the cross-department workflows that TriNet's PEO services can't handle. It launches structured processes for IT provisioning, facilities setup, training enrollment, and finance access when employee events occur in TriNet. ## The gap TriNet can't fill TriNet provides full PEO services: 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. IT still needs to create accounts. Facilities needs to prepare a workspace. Training needs to schedule orientation. Finance needs to set up expense access. TriNet can't 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-team approval workflows TriNet handles your HR outsourcing needs, but business processes span every department. Tallyfy coordinates 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 people both inside and outside the PEO relationship. ### Employee onboarding When TriNet records a new hire, Tallyfy coordinates: - 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 a 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/)**: Tallyfy acts as a coordination layer on top of UiPath, managing human-bot handoffs, exception routing, and end-to-end process tracking. RPA bots and human workers operate together in unified workflows with full visibility. ## Where UiPath falls short UiPath is great at automating repetitive, rule-based tasks on screens. But most business processes need BOTH automated AND human activities - and UiPath can't coordinate both. A UiPath bot extracts data from an invoice. What happens next? Who reviews exceptions? How do you track whether the full process actually completed? UiPath automates individual tasks - it doesn't connect entire processes that span bots and people. **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 - Exceptions requiring human judgment - End-to-end visibility across automated and manual steps - Accountability for process outcomes - Routing to different teams based on exceptions UiPath automates tasks. Tallyfy coordinates processes - combining bots and humans in unified workflows with full visibility. ## How Tallyfy fills this gap Tallyfy acts as the coordination layer connecting UiPath with human workflows to create end-to-end process automation. ### Process coordination When UiPath bots run, 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 smooth transitions: - Bot completes data extraction → Tallyfy assigns human review - Human approves exception → Tallyfy triggers next bot via Orchestrator API - Full audit trail of who did what and when ### Exception management When UiPath hits something it can't handle: - Tallyfy receives the exception notification - Routes it to the right human reviewer - Tracks resolution time and outcome - Resumes automation once the 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 setups. **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 connecting UiPath with your Tallyfy workflows. We'll help you find processes where human-bot coordination can reduce exceptions and improve completion rates. - **[UKG Pro](https://tallyfy.com/products/pro/integrations/vendors/ukg-pro/)**: Tallyfy adds a cross-department workflow layer on top of UKG Pro. It handles integration delays and manual handoffs between HR, IT, Finance, and Operations that UKG Pro's multi-database architecture can't manage alone. ## The gap UKG Pro can't fill UKG Pro handles workforce management, scheduling, and HR for large enterprises. But its multi-database architecture means integration projects can drag on for months, support response times stretch, and cross-department coordination stays manual. Employee changes need handoffs between HR, IT, Finance, and Operations - and UKG Pro simply isn't built for that. Data lives in multiple internal stores, creating consistency headaches and extra steps for routine 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 heavy configuration - Self-service workflows for common HR requests UKG Pro covers enterprise workforce management well. Process coordination? That needs something faster and more flexible. Tallyfy provides the workflow layer that bridges UKG data with cross-team execution. ## How Tallyfy fills this gap Tallyfy sits between UKG Pro and your cross-department processes - giving you speed and visibility that UKG's architecture can't deliver on its own. ### Faster 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 a 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. - **[Workday](https://tallyfy.com/products/pro/integrations/vendors/workday/)**: Tallyfy coordinates the cross-department workflows that Workday can't handle. It automatically launches structured onboarding and offboarding processes across IT, Facilities, Finance, and Training teams when employee events like hires or terminations occur in Workday. ## The gap Workday can't fill Workday centralizes HR and financial data for large enterprises. But the moment someone gets hired, a cascade of coordination begins - and Workday doesn't handle it. Workday can't tell IT to order a laptop. It can't tell Facilities to assign a desk. It won't schedule orientation with Training or notify Finance to create an expense account. These handoffs end up in emails, spreadsheets, and chat threads - untracked and invisible. **What Workday manages:** - Employee records and org structure - Payroll 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-team 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 Workday serves your HR and Finance teams. Employee lifecycle processes span every department. Tallyfy coordinates 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 kicks off: - 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 a custom integration using [Tallyfy's API](/products/pro/integrations/open-api/) with Workday's REST APIs or Integration Cloud. For technical 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 Tallyfy. We'll look at your current Workday setup and find the best automation opportunities. - **[WorkFusion](https://tallyfy.com/products/pro/integrations/vendors/workfusion/)**: Tallyfy coordinates WorkFusion's AI automation with the human activities it can't manage alone, routing low-confidence items to reviewers and handling exception escalation and approval workflows for high-stakes AI decisions. ## The gap WorkFusion can't fill WorkFusion combines AI and RPA to automate judgment-intensive processes. Its machine learning models improve over time, handling increasingly sophisticated decisions. But even the best AI can't 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. New document types need human guidance. High-stakes outcomes need human oversight. WorkFusion augments human work - but it can't manage 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 coordination for model training - Exception escalation to experts - Approval workflows for high-stakes AI decisions - Visibility across 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 handles the complete process - coordinating AI automation with human oversight, exception handling, and approval workflows. ## How Tallyfy fills this gap Tallyfy acts as the coordination layer connecting 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 the right experts - Tracking human-AI collaboration metrics ### AI-human handoffs Tallyfy keeps transitions smooth: - AI processes routine items automatically - Borderline cases route to a 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 the item with a confidence score - Tallyfy routes it based on confidence thresholds - A specialist reviews and decides - The decision gets 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 coordinate 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 connecting WorkFusion with your Tallyfy workflows. We'll help you build effective human-in-the-loop processes that improve AI performance over time. - **[Zendesk](https://tallyfy.com/products/pro/integrations/vendors/zendesk/)**: Zendesk captures customer support conversations across channels but can't coordinate the multi-team workflows needed to fully resolve complex issues. Tallyfy bridges that gap by turning tickets into trackable processes with deadlines and accountability. ## The gap Zendesk can't fill Zendesk is great at capturing customer conversations across channels - email, chat, phone, social. But tickets are unstructured. They capture what was said, not what needs to happen next. When a ticket requires action from multiple teams - engineering investigates, product evaluates, docs need updating - Zendesk tracks the conversation. It doesn't coordinate the cross-team workflow that actually resolves the issue. **What Zendesk handles:** - 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 Zendesk captures support requests. Tallyfy turns them into structured processes so nothing slips through. ## How Tallyfy fills this gap Tallyfy 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 - Shows resolution progress in real time ### 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 After tickets close in Zendesk, Tallyfy handles: - 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 call](https://tallyfy.com/booking/) to discuss connecting Zendesk with your Tallyfy workflows. We'll map your complex ticket types to structured processes that resolve them fully. - **[Zoho CRM](https://tallyfy.com/products/pro/integrations/vendors/zoho-crm/)**: Tallyfy coordinates cross-department approvals, handoffs, and post-sale onboarding between Zoho CRM deal pipeline stages, whether teams use Zoho or not. ## The gap Zoho CRM can't fill Zoho CRM tracks deals through pipeline stages as part of the broader Zoho platform. But the micro-tasks between sales stages need coordination that spans people and departments - not just apps. When a deal moves from qualification to proposal, multiple team members must complete tasks in sequence. Technical scoping, pricing approval, legal review, resource allocation - each needs assignment, deadlines, and accountability. Zoho's Blueprint workflows handle simple sequences, but they don't cover 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 - 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 own platform. Tallyfy coordinates across all your teams - whether they use Zoho or not. ## How Tallyfy fills this gap Tallyfy acts as the coordination layer connecting 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 - Gives visibility across all participants ### Approval workflows When deals need 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 coordinates: - 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 a 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. - **[Zenefits](https://tallyfy.com/products/pro/integrations/vendors/zenefits/)**: Tallyfy extends Zenefits by coordinating the cross-department workflows that HR events trigger, like IT provisioning and facilities setup during onboarding, since Zenefits only handles HR administration and benefits while employee processes span every team in your organization. ## The gap Zenefits can't fill Zenefits (now TriNet Zenefits) provides all-in-one HR for SMBs - covering benefits, payroll, and compliance. But the moment HR events need cross-department coordination, things fall outside Zenefits' scope. A new hire gets recorded in Zenefits. Paperwork and benefits enrollment? Handled. But IT still needs to provision accounts. Facilities needs workspace setup. Training needs to schedule onboarding. These cross-department processes need coordination that Zenefits doesn't provide. **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-team approval chains - External vendor and contractor workflows Zenefits serves your SMB HR needs - but employee processes span every department. Tallyfy coordinates 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 coordinates: - 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 a 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. ### Bamboohr - **[BambooHR technical integration](https://tallyfy.com/products/pro/integrations/vendors/bamboohr/technical/)**: BambooHR connects to Tallyfy through REST API calls and SHA-256 HMAC webhook verification. Pull employee data and launch processes like onboarding or role changes when HR events occur. ## Connecting BambooHR to Tallyfy Connect BambooHR to Tallyfy and your HR events can start the right process on their own. Hire someone, and Tallyfy kicks off an onboarding run. Change their job, and it starts a role-change run. When they leave, it handles offboarding. Tallyfy pulls the person's details straight from BambooHR, so no one re-types names, emails, or start dates. (For the plain overview, see the [BambooHR integration](/products/pro/integrations/vendors/bamboohr/) page.) You can set this up three ways: have your system call BambooHR's API directly, listen for BambooHR's webhooks[^1], or check for changes on a schedule. Rather not write code? No-code tools like Zapier, Make, Merge, and Finch can connect the two for you. ## For developers *(Skip this unless you're setting up the technical side.)* ### REST API integration Fetch employee data from BambooHR, then launch a Tallyfy process with that data: ```javascript const handleBambooHREmployee = async (employeeId) => { // Fetch employee from BambooHR 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()); // Launch a Tallyfy process (run) for this employee const run = await fetch( `https://go.tallyfy.com/api/organizations/${orgId}/runs`, { method: 'POST', headers: { 'Authorization': 'Bearer YOUR_TALLYFY_TOKEN', 'X-Tallyfy-Client': 'APIClient', 'Content-Type': 'application/json' }, body: JSON.stringify({ checklist_id: 'f7e6d5c4b3a2918070615243342516f0', name: `Onboarding - ${employee.firstName} ${employee.lastName}`, // prerun keys are the kick-off fields' timeline IDs, not their labels prerun: { 'a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6': employee.id, // Employee ID '3c9d1e7fa4b820516d8e2f7a9c0b4d15': `${employee.firstName} ${employee.lastName}`, // Full name '9f2b7c1e4a6d8035b1c7e9d2f4a6b801': employee.workEmail, // Email '6e4a2c80f19b3d75e0a8c246b93f157d': employee.department, // Department '2d7f9a1c5e3b806478d0a2c4e6f81b39': employee.location, // Location '5b8c0e2a7f4d1936a8e0c5b3d7f92146': employee.jobTitle, // Job title '0a3e6b9d2c8f5174e9b2d6a0c4f83b57': employee.supervisor, // Manager '7c1f4a8e0b3d69257a0e4c8b2f6d1930': employee.hireDate // Start date } }) } ); return run.json(); }; ``` The `prerun` object is keyed by each kick-off field's timeline ID, a 32-character hex string. You'll find it as the `id` on each entry of the `prerun` array returned by `GET /organizations/{org_id}/checklists/{checklist_id}`. Don't use the `alias` sitting next to it - alias keys never match, and Tallyfy drops unmatched keys silently, so the process launches successfully with that field left blank. Each `prerun` value's shape depends on the field type. The per-type list lives on [Launch process](/products/pro/integrations/open-api/code-samples/processes/launch-process/). ### Webhook integration BambooHR webhooks use SHA-256 HMAC signatures. You'll need to verify every incoming request before processing it: ```javascript const express = require('express'); const crypto = require('crypto'); const app = express(); app.post('/bamboohr-webhook', express.raw({ type: '*/*' }), async (req, res) => { const signature = req.headers['x-bamboohr-signature']; const expected = crypto .createHmac('sha256', process.env.BAMBOOHR_WEBHOOK_SECRET) .update(req.body) .digest('hex'); if (signature !== expected) { return res.status(401).send('Invalid signature'); } const { type, employees } = JSON.parse(req.body); 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 If your system can't receive webhooks, BambooHR supports change reports you can poll on a schedule: ```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 mapped to Tallyfy kick-off form fields. The Tallyfy column names the field you're aiming at - in the API payload you address it by its timeline ID, not by this name. | BambooHR field | Tallyfy kick-off field | Notes | |----------------|------------------|-------| | `id` | `employee_id` | Record ID | | `firstName` + `lastName` | `full_name` | Combined name | | `workEmail` | `email` | Work email | | `department` | `department` | Department | | `division` | `division` | Division | | `location` | `location` | Work location | | `jobTitle` | `job_title` | Title | | `supervisor` | `manager` | Direct manager name | | `supervisorEmail` | `manager_email` | Manager's email | | `hireDate` | `start_date` | Hire date | | `employmentHistoryStatus` | `status` | Employment status | ### Authentication BambooHR uses 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' }); ``` ### Webhook events BambooHR webhooks can fire on these field changes: - **Employee created** - new employee added - **Job information** - title, department, or location changed - **Employment status** - active, terminated, or on leave - **Compensation** - salary or pay rate changed - **Time off** - requests or balances changed ### iPaaS alternatives If you'd rather not build a direct API integration: - **Merge API** - unified HRIS API that includes BambooHR - **Finch** - employment system API - **Zapier** - pre-built BambooHR triggers and actions - **Make** - visual workflow builder with a BambooHR connector [^1]: Webhooks are automatic messages BambooHR sends to your system the moment something changes, so you don't have to keep asking. ### Paylocity - **[Paylocity technical integration](https://tallyfy.com/products/pro/integrations/vendors/paylocity/technical/)**: Integrate Paylocity with Tallyfy through REST APIs or webhooks to automatically launch onboarding and offboarding processes. Uses OAuth 2.0 authentication with field mapping between Paylocity employee data and Tallyfy kick-off form variables. ## Integration options Paylocity offers REST APIs through their developer program. Pick the approach that fits your partnership status and technical needs. ### REST API integration Use Paylocity's REST API to trigger Tallyfy processes when employee events happen: ```javascript const handlePaylocityEvent = async (event) => { if (event.eventType === 'employee.created') { const employee = await paylocityAPI.get( `/v2/companies/${companyId}/employees/${event.employeeId}` ); // Launch a Tallyfy process (called a "run") from a template const run = await fetch( `https://go.tallyfy.com/api/organizations/${orgId}/runs`, { method: 'POST', headers: { 'Authorization': `Bearer ${tallyfyToken}`, 'X-Tallyfy-Client': 'APIClient', 'Accept': 'application/json', 'Content-Type': 'application/json' }, body: JSON.stringify({ checklist_id: 'f7e6d5c4b3a2918070615243342516f0', name: `Onboarding - ${employee.firstName} ${employee.lastName}`, // prerun keys are the kick-off fields' timeline IDs, not their labels prerun: { 'a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6': employee.employeeId, // Employee ID '3c9d1e7fa4b820516d8e2f7a9c0b4d15': `${employee.firstName} ${employee.lastName}`, // Full name '9f2b7c1e4a6d8035b1c7e9d2f4a6b801': employee.workEmail, // Email '6e4a2c80f19b3d75e0a8c246b93f157d': employee.departmentCode, // Department '2d7f9a1c5e3b806478d0a2c4e6f81b39': employee.workLocation, // Location '5b8c0e2a7f4d1936a8e0c5b3d7f92146': employee.jobTitle, // Job title '0a3e6b9d2c8f5174e9b2d6a0c4f83b57': `${employee.supervisorFirstName} ${employee.supervisorLastName}`, // Manager '7c1f4a8e0b3d69257a0e4c8b2f6d1930': employee.hireDate // Start date } }) } ); return run.json(); } }; ``` The `prerun` object is keyed by each kick-off field's timeline ID, a 32-character hex string. You'll find it as the `id` on each entry of the `prerun` array returned by `GET /organizations/{org_id}/checklists/{checklist_id}`. Don't use the `alias` sitting next to it - alias keys never match, and Tallyfy drops unmatched keys silently, so the process launches successfully with that field left blank. Each `prerun` value's shape depends on the field type. The per-type list lives on [Launch process](/products/pro/integrations/open-api/code-samples/processes/launch-process/). ### Webhook integration Register webhooks to get 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 expected = crypto .createHmac('sha256', process.env.PAYLOCITY_WEBHOOK_SECRET) .update(payload) .digest('hex'); if (signature !== expected) { 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 Here's how common Paylocity fields map to Tallyfy kick-off form fields. The Tallyfy column names the field you're aiming at - in the API payload you address it by its timeline ID, not by this name. | Paylocity field | Tallyfy kick-off field | 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, or contractor | | `hireDate` | `start_date` | Employee start date | ## Authentication Paylocity uses OAuth 2.0[^1] with the client credentials flow. Store credentials securely - don't 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 work isn't an option, consider these platforms: - **Merge API** - unified HRIS API with Paylocity support - **Finch** - employment system API with a Paylocity connector - **Flexspring** - HR integration platform - **Workato** - enterprise automation recipes [^1]: Industry-standard protocol for secure third-party authorization without sharing passwords ### Netsuite - **[NetSuite technical integration](https://tallyfy.com/products/pro/integrations/vendors/netsuite/technical/)**: Tallyfy integrates with NetSuite through REST APIs or native SuiteScript to launch processes like employee onboarding when records are created. Common fields like department and subsidiary map into Tallyfy kick-off forms. ## Integration options NetSuite's REST APIs are the preferred integration method. Pick the approach that fits your team's technical setup. ### REST API integration (recommended) Use OAuth 2.0 with NetSuite's REST API to fetch record data, then launch a Tallyfy process[^1] via the Tallyfy API. Note that Tallyfy's API uses org-scoped endpoints - templates are called "checklists" in API paths, and launching a process means creating a "run." ```javascript const handleEmployeeHire = async (employeeData, orgId, checklistId) => { // 1. Fetch employee details from NetSuite const employee = await netsuiteAPI.get(`/employee/${employeeData.id}`, { expand: ['department', 'location', 'subsidiary', 'supervisor'] }); // 2. Launch a Tallyfy process (run) from a template (checklist). // prerun keys are the kick-off fields' timeline IDs, not their labels. const run = await fetch( `https://go.tallyfy.com/api/organizations/${orgId}/runs`, { method: 'POST', headers: { 'Authorization': 'Bearer YOUR_TALLYFY_TOKEN', 'X-Tallyfy-Client': 'APIClient', 'Accept': 'application/json', 'Content-Type': 'application/json' }, body: JSON.stringify({ checklist_id: checklistId, name: `Onboarding - ${employee.entityId}`, prerun: { 'a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6': employee.id, // Employee ID '3c9d1e7fa4b820516d8e2f7a9c0b4d15': `${employee.firstName} ${employee.lastName}`, // Full name '9f2b7c1e4a6d8035b1c7e9d2f4a6b801': employee.email, // Email '6e4a2c80f19b3d75e0a8c246b93f157d': employee.subsidiary.name, // Subsidiary '2d7f9a1c5e3b806478d0a2c4e6f81b39': employee.department.name, // Department '5b8c0e2a7f4d1936a8e0c5b3d7f92146': employee.location.name, // Location '0a3e6b9d2c8f5174e9b2d6a0c4f83b57': employee.supervisor.name // Supervisor } }) } ); return run.json(); }; ``` The `prerun` object is keyed by each kick-off field's timeline ID, a 32-character hex string. You'll find it as the `id` on each entry of the `prerun` array returned by `GET /organizations/{org_id}/checklists/{checklist_id}`. Don't use the `alias` sitting next to it - alias keys never match, and Tallyfy drops unmatched keys silently, so the process launches successfully with that field left blank. Each `prerun` value's shape depends on the field type. The per-type list lives on [Launch process](/products/pro/integrations/open-api/code-samples/processes/launch-process/). ### SuiteScript integration You can also build native NetSuite scripts that fire on record events. Here's a SuiteScript example that launches a Tallyfy process whenever a new employee record is created: ```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; const orgId = 'YOUR_ORG_ID'; const checklistId = 'YOUR_CHECKLIST_ID'; https.post({ url: `https://go.tallyfy.com/api/organizations/${orgId}/runs`, headers: { 'Authorization': 'Bearer YOUR_TALLYFY_TOKEN', 'X-Tallyfy-Client': 'APIClient', 'Accept': 'application/json', 'Content-Type': 'application/json' }, body: JSON.stringify({ checklist_id: checklistId, name: `Onboarding - ${employee.getValue('entityid')}`, prerun: { 'a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6': employee.id, // Employee ID '3c9d1e7fa4b820516d8e2f7a9c0b4d15': employee.getValue('entityid') // Employee number } }) }); } } return { afterSubmit: afterSubmit }; }); ``` ## Data mapping Common NetSuite fields you'll want to map to Tallyfy kick-off form fields. The Tallyfy column names the field you're aiming at - in the API payload you address it by its timeline ID, not by this name. | NetSuite field | Tallyfy kick-off field | 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 isn't an option, consider these platforms: - **Celigo** - NetSuite-native integration platform - **Workato** - Enterprise automation with NetSuite recipes - **Boomi** - Dell Boomi AtomSphere with NetSuite connectors - **MuleSoft** - Anypoint Platform with NetSuite support [^1]: In Tallyfy's API, templates are called "checklists" and running instances are called "runs" ### Teams - **[Teams technical integration](https://tallyfy.com/products/pro/integrations/vendors/teams/technical/)**: Connect Tallyfy with Microsoft Teams using Graph API, Adaptive Cards, Power Automate, incoming webhooks, or custom Bot Framework bots. Push task notifications and workflow updates directly into Teams channels. ## Ways to connect Teams and Tallyfy Microsoft Teams integration relies on three main tools: Graph API, Adaptive Cards, and Power Automate. Pick whichever fits your setup. ### Power Automate (recommended) The easiest route 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 You can send rich, interactive cards to Teams channels whenever Tallyfy tasks get 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 Tallyfy workflow updates to Teams channels through the 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 setups, Teams incoming webhooks work well: ```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 Need richer interaction? You'll want a custom Teams bot: ```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 setup Teams integration uses Azure AD OAuth 2.0[^1]. Here's the setup in Azure portal: 1. Register your app in Azure AD 2. Add Microsoft Graph API permissions 3. Set 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 you don't want to write custom code: - **Power Automate** - Microsoft's native automation platform - **Zapier** - pre-built Teams triggers and actions - **Workato** - enterprise automation with a Teams connector - **Make** - visual workflow builder with Teams integration [^1]: Industry-standard protocol for secure delegated authorization without sharing passwords ### Workday - **[Workday technical integration](https://tallyfy.com/products/pro/integrations/vendors/workday/technical/)**: Tallyfy integrates with Workday through XML-based Integration Cloud or REST API methods to automatically launch processes like onboarding when HR events occur. iPaaS platforms like Workato or MuleSoft work as alternatives for teams without direct API access. ## Integration options Workday offers several integration methods. Pick the one that fits your technical needs and partnership status. ### Workday Integration Cloud (XML) Use Workday's native integration platform for scheduled data sync: ```xml https://go.tallyfy.com/api/organizations/{org_id}/runs ``` ### 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 response = await fetch( 'https://go.tallyfy.com/api/organizations/{org_id}/runs', { method: 'POST', headers: { 'Authorization': 'Bearer YOUR_TALLYFY_TOKEN', 'X-Tallyfy-Client': 'APIClient', 'Accept': 'application/json', 'Content-Type': 'application/json' }, body: JSON.stringify({ checklist_id: 'f7e6d5c4b3a2918070615243342516f0', // prerun keys are the kick-off fields' timeline IDs, not their labels prerun: { 'a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6': worker.employeeID, // Employee ID '3c9d1e7fa4b820516d8e2f7a9c0b4d15': worker.legalName, // Full name '9f2b7c1e4a6d8035b1c7e9d2f4a6b801': worker.workEmail, // Email '6e4a2c80f19b3d75e0a8c246b93f157d': worker.costCenter, // Cost center '2d7f9a1c5e3b806478d0a2c4e6f81b39': worker.primaryWorkLocation, // Location '5b8c0e2a7f4d1936a8e0c5b3d7f92146': worker.jobProfile, // Job title '0a3e6b9d2c8f5174e9b2d6a0c4f83b57': worker.manager // Manager } }) } ); return response.json(); } }; ``` The `prerun` object is keyed by each kick-off field's timeline ID, a 32-character hex string. You'll find it as the `id` on each entry of the `prerun` array returned by `GET /organizations/{org_id}/checklists/{checklist_id}`. Don't use the `alias` sitting next to it - alias keys never match, and Tallyfy drops unmatched keys silently, so the process launches successfully with that field left blank. Each `prerun` value's shape depends on the field type. The per-type list lives on [Launch process](/products/pro/integrations/open-api/code-samples/processes/launch-process/). ## Data mapping Here's how common Workday fields map to Tallyfy kick-off form fields. The Tallyfy column names the field you're aiming at - in the API payload you address it by its timeline ID, not by this name. | Workday Field | Tallyfy kick-off field | 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 - don't expose them in client-side code. ## iPaaS alternatives If you don't have direct API access, use an integration platform instead: - **Celigo** - NetSuite-native with Workday connectors - **Workato** - Enterprise automation recipes - **MuleSoft** - Anypoint Platform connectors - **Boomi** - Dell Boomi AtomSphere ### Pricing - **[Non-profit discount](https://tallyfy.com/products/pro/pricing/how-to-apply-for-tallyfys-nonprofit-program-discount/)**: Tallyfy offers a permanent discount on annual subscriptions for verified nonprofit and charitable organizations. Learn how to apply with official documentation and check eligibility requirements. ## What is Tallyfy's nonprofit discount? Tallyfy offers a permanent discount for qualifying nonprofit and charitable organizations. Contact Tallyfy for current rates. ## Who's eligible? Your organization needs official charitable status from a government tax authority, like IRS 501(c)(3) in the US or equivalent international certification. These categories are **ineligible**: * Political advocacy and lobbying organizations * Religious institutions and congregations * Educational institutions * Government agencies * Public opinion research organizations * Healthcare facilities and medical insurance providers * Private foundations Organizations that practice discrimination or require specific religious affiliations for service access are also ineligible. Not sure if you qualify? Contact support before applying. ## How to apply Tallyfy reviews each application. Once you're approved, Tallyfy applies the discount to your subscription. ## Terms and conditions * Tallyfy determines discount eligibility. * The discount applies permanently to annual subscriptions. * Discounts can't be applied retroactively. * Tallyfy reserves the right to approve or deny applications and to modify program criteria at any time. - **[Sales tax](https://tallyfy.com/products/pro/pricing/sales-tax/)**: Tallyfy doesn't charge sales tax because it's based in Missouri, where SaaS isn't taxable. International customers also aren't charged VAT or GST currently. You'll get advance notice if this changes. ## Sales tax on Tallyfy subscriptions **You won't see sales tax on your Tallyfy subscription.** Tallyfy is based in Missouri, where SaaS isn't subject to sales tax. We don't currently meet economic nexus thresholds in other states either, so we don't collect sales tax anywhere. ### Why Missouri doesn't tax SaaS Missouri taxes tangible personal property and certain listed services. Remotely-accessed software isn't on that list. The Missouri Department of Revenue treats SaaS differently from downloadable software. When you use Tallyfy, you're accessing servers remotely. You're not downloading anything. No physical transfer happens. That distinction keeps SaaS in the non-taxable category. Recent letter rulings from Missouri's tax authority confirm this. They've consistently held that subscription-based, remote-access digital services aren't taxable as tangible personal property or telecommunications services. ### What about other states? As a Missouri company, Tallyfy only needs to charge sales tax in other states when it hits certain thresholds, called "economic nexus." Each state sets its own thresholds, typically based on sales volume or transaction counts. Once a company crosses these thresholds, it must register and start collecting sales tax, but only if that state actually taxes SaaS. About 25 US jurisdictions tax SaaS in some form. New York, Texas, and Washington tax it fully. California and Florida don't tax it at all. Some states, like Iowa, tax it for consumers but exempt business use. We monitor our sales by state. If we cross the threshold in a state that taxes SaaS, we'll register there and update billing accordingly. Affected customers will get advance notice. ### B2B vs B2C Most US states that tax SaaS apply the same rules to both B2B and B2C transactions. A few states provide business-use exemptions, but you'd need to provide exemption certificates. Since Tallyfy primarily serves business customers, you might qualify in certain states, though we're not collecting tax anywhere right now. ### International 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 you provide a valid VAT ID - We'd use the Non-Union OSS scheme 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**: Canada has GST/HST, Australia has GST, and each country has its own rules. We're not registered for VAT in any country. If this changes, we'll provide advance notice. ### Economic nexus thresholds Thresholds vary by state and change frequently. Some states have no sales tax at all (Delaware, Montana, New Hampshire, Oregon), while others set different dollar amounts and transaction counts as triggers. ### What this means for you **For US customers**: - No sales tax on your Tallyfy subscription currently - If this changes, you'll get at least 30 days advance notice - You're still 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, and international agreements are harmonizing digital taxation. We track these changes closely: 1. Monitor sales thresholds quarterly 2. Track legislative changes in sales tax laws 3. Register early when approaching thresholds 4. Communicate changes to affected customers early ### Disclaimer This page reflects our current understanding of applicable tax laws. Tax laws change frequently, and this isn't tax advice. We base our positions on Missouri Department of Revenue guidance, state tax authority rulings, and consultation with tax professionals. Laws may have changed since this was written, and your situation might differ. ### Questions? For questions about your tax obligations, exemption certificates, international tax requirements, or changes to our tax collection, email [support@tallyfy.com](mailto:support@tallyfy.com) or use the in-app chat. We can discuss your situation, provide invoices in your required format, or point you to the right tax resources. We can't give tax advice, but we can explain our policies. ### Tracking and tasks - **[Problems with flowcharts](https://tallyfy.com/products/pro/tracking-and-tasks/can-i-build-a-flowchart-in-tallyfy/)**: Tallyfy replaces static flowcharts, spreadsheets, and documents by running and tracking your processes in real time. Teams follow workflows daily with clear task ownership, automatic reminders, and step-by-step guidance on any device. ## How Tallyfy compares to flowcharts, spreadsheets, and docs Tallyfy isn't for building flowcharts - it runs and tracks your processes instead of just drawing them. ### Why Tallyfy beats flowcharts Flowcharts show a process but can't *run* it. That's the core problem. * **Instructions, videos, and files on each step**: Attach what people need right where they need it. No hunting for that PDF guide. * **Real-time status**: See exactly where each process stands. Is John stuck on step 3? You'll know instantly. * **Deadlines and automatic reminders**: Assign tasks to specific people with due dates - Tallyfy nudges them automatically. * **People actually use it**: Unlike a flowchart gathering dust on the shared drive, Tallyfy becomes a living workflow your team follows daily. ### Why Tallyfy beats spreadsheets Tracking processes in spreadsheets gets messy fast - multiple versions, nobody updating status, broken formulas. Tallyfy fixes that: * **One place for everything**: Stop jumping between 15 spreadsheets. All your processes live here. * **Clear ownership**: Each task shows exactly who's responsible. No more "I thought Sarah was handling that." * **Steps run in order**: Workflows follow your actual process - with rules that route tasks based on previous answers. * **Permissions built in**: Contractors see only their tasks. Managers see everything. * **Always current**: Forget "Process_Tracker_v2_FINAL_FINAL.xlsx" - everyone works from the same live workflow. ![Creating a client onboarding template with Tallyfy AI](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-create-client-onboarding-template-from-tallyfyAI.png) ![Clicking create template by Tallyfy AI button](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-click-create-template-by-tallyfyai.png) ### Why Tallyfy beats documents Word docs and PDFs store information but can't run processes. When's the last time your team opened that 47-page procedures manual? * **Jump to your step**: No scrolling through pages - go straight to where you are. * **Works on any device**: Phone, tablet, laptop - Tallyfy works on all of them. * **Track who's doing what**: See who's completed steps and where things are stuck. Documents can't tell you that. * **Active, not static**: Tallyfy guides people through each step, sends reminders, and tracks completion automatically. ![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/)**: Click the bell icon in Tallyfy's top right corner to see recent alerts for task assignments, comments, deadline changes, and mentions. Use View All Notifications for your full history or Mark All As Read to clear unread items. ## View notifications Click the bell icon in the top right corner of Tallyfy to open your notifications dropdown. You'll see recent alerts, with a link to your full notification history. Tallyfy notifies you when someone assigns you a task, comments on your work, completes a task you're involved in, reports or resolves an issue, updates a deadline, or mentions you. If you've got unread notifications, a count badge appears on the bell icon. ![Tallyfy notifications dropdown showing recent alerts](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-show-notifications.png) ### How to view all notifications 1. Click the bell icon in the top right corner. 2. In the dropdown, click **VIEW ALL NOTIFICATIONS**. This takes you to your complete notification history: every alert, update, and message in one place. You can also click **MARK ALL AS READ** to clear your unread count. ![Tallyfy full notification history view](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-show-all-notifications.png) - **[Protect sensitive data](https://tallyfy.com/products/pro/tracking-and-tasks/how-can-i-protect-sensitive-data-in-tallyfy/)**: Don't store sensitive data like Social Security numbers or credit card details directly in Tallyfy. Keep them in dedicated secure systems and use secure links in task descriptions to reference that data. ## Best practices for protecting sensitive information Never store sensitive data directly in Tallyfy. Keep it in your secure systems and link to it from your workflows instead. Things like Social Security numbers, credit card details, and patient records don't belong in [task](/products/pro/tracking-and-tasks/tasks/) descriptions or form fields. ### Recommendations 1. **Store data outside Tallyfy**: Confidential info belongs in dedicated secure systems like encrypted databases, your HR platform, or specialized finance software. These systems already have the access controls you need. 2. **Limit access**: Only authorized users should reach the secure system where your data lives. 3. **Never paste sensitive details into Tallyfy**: Don't type or paste confidential data into task names, descriptions, or form fields. 4. **Link instead**: Add secure links in your Tallyfy task descriptions that point to where the data actually lives. ### How to link to sensitive data from Tallyfy 1. Store your sensitive info securely in your other system first. 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, add your secure link. For example: "Review the customer's credit application here: [secure link]" 5. Save the task description. Your workflow now references the sensitive data without storing it in Tallyfy. It's safe in your secure system, and your team can still access it when needed. ### Collecting sensitive documents 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. People upload directly to your secure DMS without files ever passing through Tallyfy. This works well for law firms, healthcare providers, and financial services where compliance matters. - **[Processes](https://tallyfy.com/products/pro/tracking-and-tasks/processes/)**: A process is a live, running instance of a template that you launch and track daily. Each process captures a snapshot of its template at launch time and can be named, auto-named, or have tasks added on the fly. ## Processes in Tallyfy A process is a running instance of a [template](/products/pro/documenting/templates/). Here's the key difference: * A **Template** is a reusable blueprint for a workflow (e.g., the steps for onboarding a new employee) * A **Process** is one specific execution of that template (e.g., onboarding *Jane Doe* starting 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** appear in all future processes launched from it - To update the template: go to **Templates** tab, edit your template, and add the task there - To add a task to one process only: open that process and use **Add Task** ::: ### Why processes matter Templates define how work should be done. Processes are the actual work happening now. - Processes are what you track daily - Processes are where team members collaborate - Processes are how you measure real progress Every time you need to run the work defined in a template, you **[launch](/products/pro/launching/)** it to create a new, trackable process instance. ## How should I name processes? Give each process a unique, descriptive name so you can tell them apart (e.g., "Onboard Jane Doe", "Onboard John Smith"). Takes seconds, saves hours. You can also set up **auto-naming** in template settings (**Settings > Summary > Auto-naming**). Tallyfy then builds process names from kick-off [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) values entered at launch. :::note[Auto-naming rules] - Auto-naming pulls from kick-off form fields referenced in the name format. Required fields are guaranteed to have values at launch. - Process names can't exceed 550 characters. ::: ## Key characteristics * A process is a snapshot of its template *at launch time*. Later template changes won't affect processes already running. :::important[Template updates don't affect running processes] When you update a template, existing processes keep their original version. That's by design: 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 **Add Task** 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 ::: * 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/) (a fillable form) * You can add extra one-off [tasks](/products/pro/tracking-and-tasks/tasks/) to any running process * Each process has its own activity log (audit trail) :::tip[Adding extra tasks] Something unexpected came up? 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] In the Tallyfy app, it's called a **Template**. In the API, it's called a **Blueprint** (model name: `Checklist`). ::: ## What happens when a process completes? Completed processes stay visible in your Tracker view. To clean up your view while keeping the data: - **Archive** - click the three-dot menu (...) on any process card in the Tracker view - **View archived** - filter by **Status = Archived** in the Tracker view - **Restore** - unarchive anytime to bring a process back 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 full steps. :::note[Archive vs. Delete] **Archiving** removes a process from active views but keeps all data. You can restore it anytime. **Deleting** permanently removes the process and all its data - this can't be undone. You must archive a process first, then delete it from the archived view. Only Admin users can permanently delete. Archiving is almost always the better choice. ::: - **[More about tasks](https://tallyfy.com/products/pro/tracking-and-tasks/tasks/)**: Tallyfy organizes all work into two types of tasks: process tasks that run inside repeatable workflow templates, and one-off standalone to-dos. Steps in templates become active tasks upon launch, and timing controls like start times and deadlines keep everyone aligned. ## What are tasks in Tallyfy? Tasks are the work items your team completes in Tallyfy every day. There are two types. ### Why do tasks matter? Tasks drive everything in Tallyfy. When your team understands them: - Everyone knows exactly what to do - no "what's next?" confusion - Work gets done right, by the right people, at the right time - AI can help complete tasks automatically with [BYO AI integration](/products/pro/integrations/byo-ai/) Curious why AI handles a single task well but stumbles on a whole job? Try the [AI task reliability calculator](https://tallyfy.com/tools/ai-task-reliability/). ### What timing concepts apply to tasks? Tallyfy gives you two timing controls: - **Start time** - when someone should begin working on the task. It's guidance, not enforced - **Deadline** - the hard stop. Miss this and it shows as overdue You can set both on templates and one-off tasks. 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/). ### Two types of tasks 1. **Process tasks** - these live inside your [process templates](/products/pro/documenting/templates/), connected to other tasks in a workflow. Perfect for anything you do repeatedly 2. **One-off tasks** - quick, standalone to-dos. No template needed. Create it, assign it, done ### What's the difference between tasks and steps? **Steps** live in templates. **Tasks** live in running processes. When you build a [template](/products/pro/documenting/templates/), you add steps - the blueprint. Each step has a type (task, approval, expiring, email, or expiring email). When you [launch](/products/pro/launching/) that template, those steps become tasks that people complete. The step's type carries over directly - a task step becomes a task, an approval step becomes an approval task. See all available types in 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? Explore the [different types of tasks](/products/pro/tracking-and-tasks/tasks/what-types-of-tasks-can-i-create-with-tallyfy/) Tallyfy offers - each type solves specific workflow problems. 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/). When things go sideways, [report and resolve issues](/products/pro/tracking-and-tasks/tasks/how-to-report-and-resolve-issues-in-tallyfy/) using Tallyfy's blocker system. - **[Tasks view](https://tallyfy.com/products/pro/tracking-and-tasks/tasks-view/)**: The Tasks view in Tallyfy's left sidebar shows every task from all running processes and standalone one-off tasks. Filter by assignee, status, and tags to quickly find and manage your work. ## The Tasks view Click **Tasks** in the left sidebar to see all your tasks in one place - from every running process and any standalone one-off tasks you've created. It's your master to-do list in Tallyfy. ### How do I use filters? Click the **Filters** button to narrow down your task list. Here's what you can filter by: * **Assignee** - your own tasks, a specific coworker, a guest (by email), everyone, or unassigned tasks * **Status** - "To Do" (default) or "Completed" * **Task state** - "Overdue", "Due Soon", or "On Time" * **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 full details on filters and sorting. :::tip[Can't find a task? Check your filters] Missing a task you know exists? It's almost always the filters. Try filtering by guest email, or switch Status to "Completed". The filters are probably hiding what you're looking for. ::: :::note[Tasks mixed from multiple processes?] The Tasks view shows ALL tasks from ALL processes mixed together. That's by design - it's a personal to-do list. If you need a process-grouped view: 1. Use the **Tracker view** instead - it organizes by process 2. Click into a specific process to see only its tasks 3. Or filter by template/process name to focus on one workflow ::: ### How can I create tasks from this view? Hit the **+ Create** button to [create a one-off task](/products/pro/tracking-and-tasks/tasks/how-to-create-a-one-off-task-in-tallyfy/) - perfect for quick to-dos that don't need a full process. - **[Tracker view](https://tallyfy.com/products/pro/tracking-and-tasks/tracker-view/)**: Tallyfy's Tracker view is your real-time dashboard for all running processes. View them in board or table format, filter by presets, and sort to spot bottlenecks across your organization. ## The Tracker view The **Tracker** view is your real-time dashboard for all running processes. Monitor progress, spot bottlenecks, and catch problems early, all from one screen. Unlike the Tasks view (your personal to-do list), the Tracker shows the big picture across your whole organization. You see where work flows smoothly and where it doesn't. ## Key features ### Display options Tallyfy gives you two ways to view your processes: * **Board View** - Visual cards showing each process with status indicators, assignees, and progress bars. Good for kanban-style tracking. * **Table View** - A spreadsheet-like format with sortable columns. Better for sorting, filtering, and working with many processes at once. Switch between views anytime. 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 details. ### Filtering The Tracker comes with built-in filter presets: - **All processes** - everything in your organization - **My processes** - processes where you're involved - **Overdue processes** - anything past its deadline - **Favorites** - processes you've starred - **Overdue problems** - processes with unresolved issues - **Untagged** - processes without tags - **Archived** - completed or shelved processes You can also filter by assigned members, tags, template type, and folder. Save custom filter combinations as presets for quick access. ### Process management actions From the Tracker, you can: - Archive processes to remove them from active views - Organize processes into folders - Star processes as favorites for quick access - Export process data to CSV - View all form field responses using the **Preview** option inside a process :::tip[Viewing all form data in one place] Open any process from the Tracker and switch to the **Preview** option. This shows all form field responses collected throughout the process in a single summary. No need to click through each task individually. ::: :::note[Table view export requirements] **You must select a specific template** before the export option becomes available in table view. **Why?** Different templates have different field structures, so CSV exports need consistent columns. Cross-template data would create incompatible headers. **For multi-template exports**: 1. Export each template separately, then combine in a spreadsheet 2. Use [Tallyfy Analytics](/products/pro/integrations/analytics/) for cross-template reporting ::: ### Custom view display logic **Why you see completed processes**: Custom views show processes where you're **involved**, not just where you have outstanding tasks. You're "involved" if: - You were assigned to any task (even completed ones) - You were mentioned in comments - You participated in approval steps - You're the process owner **To focus on current work**: - Use the **My processes** preset to see only processes you're involved in - Apply a status filter for "Active" to hide completed processes - Archive finished processes to remove them from active views ### Sorting options **Board view sorting** (from the sort dropdown): - Newest first / oldest first (by created date) - Most delayed - Name A-Z / Name Z-A **Table view sorting** - click any column header to sort by: name, progress, status, due date, started by, process owner, favorites, start date, last updated, assignees, next step, and more. **Not available yet** - sorting by custom form field data (kick-off form dates, dropdown selections, number fields). Workarounds: 1. Include sort-relevant data in process names (e.g., "2025-08-12 - Client Onboarding") 2. Export to CSV and sort in spreadsheet software 3. Use filters instead of sorting 4. Save different filtered presets for different needs :::note[Future enhancements] Calendar, Gantt chart, and Timeline views are being explored, along with form field sorting. Share your preferences with Tallyfy support. ::: ### 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 a 49-column CSV file with tasks, form answers, comments, and timestamps. You can also bulk export multiple processes using an open-source Python script for analysis, reporting, and auditing. ## Export processes to CSV format Export any running [process](/products/pro/tracking-and-tasks/processes/) to CSV directly from Tallyfy. Open the process, click the **More** menu, and select **Export CSV**. The file downloads in seconds with all tasks, form answers, comments, and timestamps. This is a Pro plan feature. Light members can't access it. ### What do I need? - View access to the running process - Admin or Standard member role (not Light) ### How do I export a process to CSV? ### What's in the CSV file? Each row represents a task, form field answer, or comment. You'll get 49 columns covering: * **Process info** - name, ID, source template, start/end dates, owner * **Task info** - name, status (complete, active, waiting), due dates, completion times, assignees * **Milestone data** - IDs, names, and positions for milestone checkpoints * **Form field data** - field names, answers, field types, file upload details * **Hidden [tasks](/products/pro/tracking-and-tasks/tasks/)** - even auto-skipped tasks appear in exports, which helps for audits * **Comments and issues** - comment text, issue reports, resolution status The [CSV file structure article](/products/pro/integrations/analytics/how-is-the-csv-file-structured-in-tallyfy/) covers all 49 columns in detail. :::note[Timestamp handling in exports] Timestamps in CSV exports use `YYYY-MM-DD HH:MM:SS` format without timezone info. In Tallyfy's interface, these same timestamps display in your personal timezone setting. ::: ![CSV export spreadsheet with process data](https://screenshots.tallyfy.com/tallyfy/pro/analytics-csv-export-spreadsheet.png) ### Bulk export for multiple processes For exporting many processes at once, use the open-source Python script in the [api-support repository](https://github.com/tallyfy/api-support/tree/master/Bulk%20Exports). It can: - Export all processes to a single CSV - Filter by status (active, complete, or all) - Filter by template ID - Handle pagination automatically ```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. See [API code samples](/products/pro/integrations/open-api/code-samples/) for more programmatic options. ### Alternative export methods Besides manual CSV export, you can: - **Use webhooks** to send form data to external systems automatically when tasks complete - **Connect via API** to pull form field data programmatically - **Set up middleware** (Zapier, Make) to stream form responses to spreadsheets See [webhook setup](/products/pro/integrations/webhooks/how-to-set-up-webhooks-in-tallyfy/) for automated data export. ### Common uses for exported data 1. **Analysis** - open in Excel or Google Sheets to measure task durations, find bottlenecks, or compare team performance 2. **Reporting** - build charts showing completion trends, cycle times, or bottleneck patterns 3. **Backup** - keep offline copies of important processes for future reference 4. **Integration** - feed data into Power BI, Tableau, or other analytics tools 5. **Auditing** - every action, timestamp, and decision is recorded for compliance :::note[Large files] Processes with hundreds of tasks may produce large CSV files. Excel and Google Sheets handle most files fine, but for thousands of rows, consider a database tool. ::: - **[Process comments](https://tallyfy.com/products/pro/tracking-and-tasks/processes/how-can-i-manage-comments-in-tallyfy/)**: Add and manage comments on running processes for workflow-level discussions and @mention people to notify them directly. Only comment authors or admins can edit or delete comments, and template comments don't carry over to launched processes. ## Add, edit, and delete comments on processes Comments on a [process](/products/pro/tracking-and-tasks/processes/) are for discussions about the overall workflow - not individual [tasks](/products/pro/tracking-and-tasks/tasks/). Anyone who can view the process can typically see and add comments. ### How do I add a comment? ### How do I @mention people? Type `@` followed by someone's name to notify them directly. The mentioned person gets a notification. @mentioning someone on a task can also auto-assign them if they don't already have access. :::note[Hourly limits protect your organization] To stop spam, each organization can post up to 120 comments per hour, and mentioning new email addresses (which invites them as guests) is capped at 30 guest invites per hour. If you hit a cap, the error tells you how long to wait before trying again. ::: ### How do I edit a comment? You can only edit your own comments. Organization admins can edit any comment. ### How do I delete a comment? Deleted comments can't be recovered. Like editing, only the comment author or an organization admin can delete a comment. ### Process comments vs. task comments - **Process comments** - general discussion about the whole workflow, visible in the main process view. - **[Task](/products/pro/tracking-and-tasks/tasks/) comments** - questions or updates about a specific task, visible only when you open that task. ### Comment history All comments are saved with the process as a permanent record. This helps when reviewing past decisions or onboarding new team members. ### Do template comments carry over? No. Comments on a template stay with the template - they don't appear when you launch a process from it. Template comments are for design discussions; process comments are for the actual running work. - **[Share a process](https://tallyfy.com/products/pro/tracking-and-tasks/processes/make-a-process-public/)**: Generate a read-only public link for any running process so outsiders can view real-time progress without an account. Control whether comments, form fields, and assignees are visible. Making a process public also expands what guest users can see. ## Make a process visible to outsiders :::note[Who can do this?] The **Permissions** tab on a running process is visible to **Administrators**, **process owners**, and the **person who started the process**. Only these [roles](/products/pro/documenting/members/) can toggle the public setting. ::: You can generate a read-only public link to any running process. Anyone with the link can view progress in real-time - no Tallyfy account needed. They can't change anything. ### How do I get the public link for a process? :::caution[Security implications] **Anyone** with this link can view the process details you've chosen to expose - task statuses, comments, form field answers, and assignee names depending on your visibility toggles. If you only need specific external people to complete certain tasks, it's safer to add them as [guests to those steps](/products/pro/documenting/guests/how-can-i-assign-tasks-to-guest-users-in-tallyfy/) instead. ::: ### How does the public setting affect guest visibility? Making a process public also changes what your [guests](/products/pro/documenting/guests/) can see in the [Tracker view](/products/pro/tracking-and-tasks/tracker-view/): - **Private process** (default) - guests only see their own assigned tasks - **Public process** - guests can see **all tasks** in the process, even ones they're not assigned to :::warning[Guest visibility when public] With a public process, every guest assigned to any task can see all tasks in the workflow: - Tasks assigned to other guests or vendors - Internal company tasks - Form field data, comments, and file attachments If multiple external vendors work on different parts of a project, they'll all see each other's tasks and your internal work. That's great for transparency - but not always what you want. ::: The [Tasks view](/products/pro/tracking-and-tasks/tasks-view/) works differently. Guests still only see their own assigned tasks there, regardless of the public setting. :::warning[Guest privacy] If your process has tasks assigned to different external guests who shouldn't see each other's work, keep the process private. ::: - **[Process lifecycle management](https://tallyfy.com/products/pro/tracking-and-tasks/processes/process-lifecycle-management/)**: Every Tallyfy process moves through five phases, from creating a template to reviewing completed results. Learn how to manage each phase and handle common challenges like bottlenecks and missed deadlines. ## Process lifecycle in Tallyfy Every process moves through five phases: create, launch, execute, monitor, and complete. ### The five phases 1. **Creation** - Build the template with steps, assignments, and form fields 2. **Launch** - Start a named instance with customized settings 3. **Execution** - Assignees complete tasks one by one 4. **Monitoring** - Track progress and catch issues early 5. **Completion** - All tasks finish and you review the results ### Creating templates - **Order steps logically** - match the order people actually do the work - **Write clear instructions** - explain each step as if it's someone's first day - **Assign by role** - use groups so new hires automatically get the right tasks - **Add form fields** - capture data at the point it's needed - **Set up automations** - auto-assign tasks, set deadlines, trigger reminders ### Launching processes - **Customize the instance** - adjust deadlines and assignments for this specific run - **Name it clearly** - Tallyfy can auto-name processes using a format you define in the template - **Notifications go out automatically** - assignees get alerted about new tasks - **Verify before launch** - check assignments and deadlines look right ### Monitoring active processes The Tracker view shows all active processes at a glance. - **Spot status fast** - processes show as active, complete, or flagged with a problem - **Check stuck tasks** - something sitting for 3 days? Nudge someone or reassign it - **Read comments** - blockers and "waiting on vendor" updates live in task comments - **Review form data** - catch incomplete submissions before they cause downstream issues ### Tracking best practices - **Pick a rhythm** - Monday morning review, Thursday deep dive - whatever works - **Watch for patterns** - multiple processes stuck at the same step? That's a bottleneck - **Tune alerts** - only get notified for events that actually matter - **Check deadlines early** - catch approaching due dates before tasks go overdue ### Completing a process A process moves to "complete" status once all its tasks are done and the kick-off form (if any) is submitted. Then: - **Verify captured data** - confirm required fields have values - **Export if needed** - pull data for reports or audits - **Archive** - store completed processes for future reference - **Improve the template** - find steps that were consistently late or skipped, then adjust ### Common challenges | Challenge | Solution | |-----------|----------| | Bottlenecks | Check workloads - if one person has 15 tasks and another has 2, rebalance | | Missed deadlines | Build in buffer. If it really takes 3 days, don't set a 2-day deadline | | Incomplete data | Make critical fields required so people can't skip them | | Abandonment | Set up a reminder rule - a nudge before things go stale | | Unclear responsibility | Assign to specific roles. "Marketing team" is vague - "Content Manager" is clear | | Missed steps | Every task lands in someone's queue. Tallyfy won't let steps vanish | | Downstream issues | A daily Tracker check catches problems while they're still small | ### Analyzing after multiple runs After 10-20 runs, you'll have enough data to spot trends. - **Compare completion times** - check actual vs. expected durations. For effort tracking, see [how to track time spent on tasks](/products/pro/tutorials/how-to/track-time-in-tasks/) - **Find recurring stalls** - three processes stuck at legal review? That's your bottleneck - **Ask your team** - collect specific pain points from the people doing the work - **Change one thing at a time** - adjust a single element, then check metrics after 5-10 more runs - **[Edit processes](https://tallyfy.com/products/pro/tracking-and-tasks/processes/edit-processes/)**: Edit any running process independently from its original template. Add new tasks, reassign existing ones, adjust due dates, rename, or archive the instance while the master template stays unchanged. ## Edit running processes You can edit a [process](/products/pro/tracking-and-tasks/processes/) after it's launched without touching your original template. Every change applies only to that specific run. Here's what you can change: * Add one-off [tasks](/products/pro/tracking-and-tasks/tasks/) that weren't in the template * Reassign tasks, adjust due dates, or update other task details * Rename the process instance * Archive or permanently delete the process when it's done Your template stays untouched. Think of it like editing a copy of a document - the master version doesn't change while you customize the working copy. ### 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 lets you insert new tasks into already-running processes without restarting or modifying the original template. You can type directly in the process view or link a pre-made one-off task to a specific position. ## 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 launch. No need to restart the process or touch the original template. There are two ways to do this. ### Method 1: Add tasks directly in the process view ### Method 2: Link an existing one-off task ### Things to know about added tasks - There's no limit on how many tasks you can add. - Added tasks show a "Linked to" indicator so you can tell them apart from original template tasks. - Adding tasks to a running process does **not** change your original template. :::note The template must have ad-hoc tasks enabled (this is on by default). If it's been disabled, you'll see an "Ad-hoc tasks not allowed for this process" error. ::: - **[Auto-name a process](https://tallyfy.com/products/pro/tracking-and-tasks/processes/edit-processes/how-can-i-auto-name-a-process-in-tallyfy/)**: Tallyfy's auto-naming feature lets you define a naming pattern in any template using static text and kick-off form variables. Every launched process gets a consistent, structured name instead of random or blank titles. ## Why auto-name processes? Auto-naming creates a consistent naming pattern for every [process](/products/pro/tracking-and-tasks/processes/) launched from a [template](/products/pro/documenting/templates/). It pulls values directly from your kick-off form fields and builds the process name automatically - so you don't end up with "Untitled" or inconsistent names across your team. | Without auto-naming | With auto-naming | | -------------------------------- | ------------------------------------- | | 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 it up? Configure auto-naming once in your template. Every process launched from it gets a properly structured name. When someone launches a process, Tallyfy fills in the variable values from the kick-off form and generates the name. No manual typing needed. :::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. Textarea, file upload, and table fields can't be used as variables. Required fields always have values - so your process names won't end up with blanks. ::: :::note[Name length limit] Process names max out at 550 characters. That's plenty for most patterns, but keep it reasonable if you're combining many variables. ::: :::note[Allow launcher to change name] When auto-naming is on, you'll see a second toggle - **Allow launcher to change name**. If set to **No**, the person launching the process can't edit the auto-generated name. If set to **Yes**, they'll see a pencil icon to override it. ::: - **[Delete a process](https://tallyfy.com/products/pro/tracking-and-tasks/processes/edit-processes/how-can-i-delete-a-process-in-tallyfy/)**: Tallyfy requires Admin users to first archive a process before the permanent delete option appears in Tracker view. This two-step flow prevents accidental, irreversible data loss. ## Permanently delete an archived process You can't delete active or completed [processes](/products/pro/tracking-and-tasks/processes/) in Tallyfy directly. You must **archive them first** - only then does the delete option appear. Once deleted, the process and all its data are gone forever. **There's no undo.** Tallyfy enforces this two-step flow to prevent accidental data loss. :::caution Only **Admin** users can permanently delete processes. Standard and Light members won't see the delete option. ::: Need to archive a process first? See [How to archive and unarchive processes](/products/pro/tracking-and-tasks/tracker-view/organize-processes/how-to-archive-and-unarchive-processes-in-tallyfy/). - **[Rename a process](https://tallyfy.com/products/pro/tracking-and-tasks/processes/edit-processes/how-can-i-rename-a-process-in-tallyfy/)**: Tallyfy lets you rename any running process at any time by clicking its name at the top of the process view and typing a new name up to 300 characters long. ## Change the name of a running process Click the process name at the top of any running [process](/products/pro/tracking-and-tasks/processes/) to rename it. It's available anytime after launch. Here's where to click: ![Rename process dialog in Tallyfy](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-change-process-name.png) - **[Add process notes](https://tallyfy.com/products/pro/tracking-and-tasks/processes/edit-processes/how-to-add-process-notes/)**: Process notes in Tallyfy let you attach rich text context to any running process. That information automatically appears on every task, so all participants stay aligned without hunting through emails or chat threads. ## How do process notes work in Tallyfy? Process notes let you add rich text to a running [process](/products/pro/tracking-and-tasks/processes/). They're visible in the process settings and on every [task](/products/pro/tracking-and-tasks/tasks/) in the **Process Details** section - so nobody misses key context regardless of which task they're working on. - **Add context** - background info about what's special about this run - **Keep everyone aligned** - notes show on every task automatically - **One place for details** - no more hunting through emails or chat threads ### How do I add or edit process notes? :::note[Who can edit process notes?] Admins, the process owner, and the process starter can edit notes. Notes can't be edited on archived processes. ::: ### Where do process notes appear? 1. **Process settings** - in the **Summary** tab where you edit them 2. **Every task** - in the collapsible **Process Details** section, so all participants see the same info ### What to include in process notes - **Context** - why you're running this process and any special circumstances - **Links** - URLs to documents, systems, or tools people need - **Contacts** - people who aren't in the process but might need to be reached - **Exceptions** - any unusual requirements for this specific run - **Updates** - add new info as it comes up during the process ### Tips for writing good process notes - **Keep it short** - notes show on every task, so don't write walls of text - **Use formatting** - bold text and bullet points make notes scannable - **Skip duplicates** - if it's already in a task description, don't repeat it in notes - **[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/)**: Tallyfy lets you modify a running process without restarting it. Open the process from Tracker view and click the Settings gear icon to rename it, reassign the owner, add notes, or export data. ## Edit running process properties You can change process settings while a process is running. Open the process and click **Settings**. You don't need to start over. ### How do I access process settings? ### What can I edit in the settings panel? The Summary tab lets you change: * **Process Name** - click the name at the top and type a new one. Hit Enter to save. * **Process Owner** - click the pencil icon next to the owner's name to reassign. ![Changing the process owner in Tallyfy](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-change-process-owner.png) * **Process Notes** - add context about this specific run using the rich text editor. The panel also shows read-only info: * Tasks completed count, creator, and start date * 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/) You can't manage tags and folders from this panel. Use the process card in the **Tracker** view instead. ### What other process actions are available? You can **Export CSV** to download all process data. The settings panel also has **Permissions** and **Activity** tabs. :::note[Where can I archive a process?] You'll find the archive option in the **Tracker view**. Click 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 details. ::: :::note[What permissions do I need to edit processes?] Administrators can edit everything. Standard members may have restrictions. Process owners get more control over their own processes. ::: ### Tasks - **[Choosing the right field type](https://tallyfy.com/products/pro/tracking-and-tasks/tasks/choosing-the-right-form-field-type/)**: Pick the right form field type in Tallyfy to improve data quality and enable automation rules. Covers radio buttons, dropdowns, checklists, and common mistakes to avoid. ## Which form field should you use? The right field type depends on what the data represents and how people will interact with it. A wrong choice creates confusion or meaningless data. ### Quick decision guide | What you need | Best field type | Why | |---------------|-----------------|-----| | Pick ONE from 2-5 options | **Radio buttons** | All options visible at once | | Pick ONE from 6+ options | **Dropdown** | Saves space, searchable | | Confirm multiple items done | **Checklist** | Multi-select with validation | | Yes/no confirmation | **Radio buttons** | Two clear, unambiguous options | | A specific date | **Date** | Calendar picker prevents format errors | | A detailed explanation | **Long text** | Room for multi-line responses | | Brief data (name, number) | **Short text** | Single line, optional validation | | Upload evidence/files | **File upload** | Multiple files, up to 100MB each | | Select a person | **Assignee picker** | Pulls from Tallyfy members, groups, and guests | | Structured data rows | **Table** | Defined columns, unlimited rows | ### When NOT to use a checklist A single-item checklist isn't a real choice - it's just confirmation. Use a different approach when you only have one thing to verify. | Instead of this | Use this | Example | |-----------------|----------|---------| | Checklist with 1 item | **Yes/No radio buttons** | "Has payment been received?" | | Single-option dropdown | **Yes/No radio buttons** | "Approved?" with Yes/No | | Checkbox for confirmation | **Radio buttons + conditional fields** | See example below | **Better pattern - payment confirmation:** 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 captures actual proof - not just a meaningless single selection. ### When to use checklists Checklists shine for multi-item verification: - Confirming several related items were completed - Order of completion doesn't matter - Some or all items may apply **Good 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" **Validation options:** - At least one item checked (mark field as required) - All items checked (enable the "must all be checked" setting) - No validation (purely informational) ### Radio buttons vs dropdown Both let you pick ONE option. The difference is display. **Radio buttons** - best for 2-5 options where you want all choices visible at once. Radio fields require at least 2 options. **Dropdown** - best for 6+ options, or when screen space is tight and options are self-explanatory. For yes/no questions, always use radio buttons. A two-item dropdown just adds an unnecessary click. ### Field types and automation rules Your field choice affects what [automation rules](/products/pro/documenting/templates/automations/) you can build: | Field type | Available rule conditions | Example | |------------|--------------------------|---------| | Radio buttons | Equals, not equals, contains, is empty | If "Priority" = "High" then assign to Manager | | Dropdown | Equals, not equals, contains, is empty | If "Department" = "Finance" then show finance steps | | Checklist | Contains, not contains, equals, is empty | If "Requirements" contains "Legal Review" then show legal step | | Short text | Contains, equals, greater/less than, is empty | If "Country" contains "USA" then show US compliance step | | Date | Equals, greater/less than, is empty | If "Start Date" is past today then show warning | ### Common mistakes 1. **Dropdown for binary choices** - Use radio buttons. Dropdowns add an unnecessary click for yes/no decisions. 2. **Single-item checklists** - Not useful. Use radio buttons or conditional fields instead. 3. **Long text for structured data** - Use separate short text fields or a table when you need specific pieces of information. 4. **File upload for simple confirmations** - Don't require uploads when a radio button would do. It creates friction. 5. **Missing validation** - Mark required fields as required. Enable email validation on text fields that collect email addresses. - **[Duplicate or clone tasks](https://tallyfy.com/products/pro/tracking-and-tasks/tasks/duplicate-clone-tasks/)**: Duplicate any template step in Tallyfy to clone its name, type, form fields, assignments, deadlines, and settings. The new step appears right after the original, letting you quickly build repetitive workflows without starting from scratch. ## How to duplicate steps You can duplicate any step in a Tallyfy template to create a copy with the same settings, form fields, and assignments - minus comments and historical data. This saves time when multiple steps share most of their configuration. Useful when you're creating multiple approval steps, collecting the same data at different stages, or any time steps share most of their setup. ## Prerequisites - Admin or Standard user role (Light members can't duplicate) - A [template](/products/pro/documenting/templates/) in edit mode - An existing step to duplicate ## How to duplicate a step in templates ## What gets copied ### Copied - Step name (appended with " - Copy") - Step type (task, approval, expiring, email, or expiring email) - All form fields and their settings - Description and instructions - Deadline settings - Assignees, groups, and guest assignments - Tags - Webhook settings - Advanced settings ### Not copied - Comments - Completion status - Historical data - Internal IDs (Tallyfy generates new ones) ## Best practices 1. **Rename right away** - get rid of the " - Copy" suffix. Stacking copies like "Task Name - Copy - Copy" gets confusing fast 2. **Check assignments** - the clone inherits assignees, groups, and guests from the original. Verify they're correct for the new step 3. **Review form fields** - copied fields might need different labels or options for the new context 4. **Check step order** - clones land right after the original. Drag them to the correct position in your workflow ## Example: multiple department approvals Need Finance, Legal, and Operations to each approve something? 1. Build the Finance approval step with all fields 2. Duplicate it twice 3. Rename to "Legal Approval" and "Operations Approval" 4. Change assignees for each department 5. Add any department-specific fields - maybe Legal needs a compliance checkbox ## Tips - **Perfect the original first** - fixing the same typo across 10 duplicated steps isn't fun - **Use variables** - set up [variables](/products/pro/documenting/templates/variables/) in your original step so all clones pull from shared data - **[Complete or reopen tasks](https://tallyfy.com/products/pro/tracking-and-tasks/tasks/how-can-i-complete-or-reopen-tasks-in-tallyfy/)**: Complete tasks by clicking the checkmark icon or the Complete button. You can reopen tasks, restrict completion to assigned members, and enforce checklist requirements before marking tasks done. ## Complete or reopen tasks ### How do I complete tasks in Tallyfy? Complete [tasks](/products/pro/tracking-and-tasks/tasks/) in two ways - click the checkmark icon in any list view, or open the task and hit **Complete**. That's it. Task marked complete. ### How do I reopen completed tasks? Need to undo a completion? Open the task and click **Re-Open**. The task goes back to active status. ### How can I control who completes or reopens tasks? Restrict task completion and reopening to assigned members only with 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/): When this is on: * Only assigned people can complete the task * Only assigned members can reopen it after completion * Non-assignees won't see the **Complete** or **Re-Open** buttons * Nobody can accidentally complete someone else's work :::note[Admin override] Admins can always complete, reopen, or edit any task - regardless of this setting. ::: ### How do I complete tasks that have subtasks (checklists)? Tasks with a checklist [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) work a bit differently. The checklist acts like mini subtasks you need to check off. You can't complete a task until all required fields are filled out - including checklist requirements. The **Complete** button stays grayed out until everything's done. :::caution[Unresolved issues block completion] If a task has unresolved issues (problems), you can't complete it. Resolve all open issues first by adding a comment and marking them resolved. ::: :::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 lets you add, edit, and delete comments on any task using a rich text editor with @mentions that instantly notify teammates. You also control guest visibility and emoji reactions. ## Comment management in Tallyfy Add, edit, and delete comments on any task in Tallyfy. Open the task, type your message, use @mentions to notify teammates, and post. ### Add comments to tasks Your comment appears with your name and timestamp. :::note[Guest comments] [Guests](/products/pro/documenting/guests/) assigned to a task can comment too - they only see their specific task, not the whole process. ::: ### Edit comments You can only edit your own comments (unless you're an Admin). ### Delete comments Only the comment author or an Admin can delete a comment. Deletion is permanent. ### Use @mentions Type `@` followed by someone's name. Pick them from the dropdown. 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. ::: :::note[Hourly limits protect your organization] To stop spam, each organization can post up to 120 comments per hour, and mentioning new email addresses (which invites them as guests) is capped at 30 guest invites per hour. If you hit a cap, the error tells you how long to wait before trying again. ::: ### Guest visibility Tallyfy hides comments from guests by default. When posting a comment, use the visibility dropdown (lock/unlock icon) to switch between **Hide from guest** and **Visible to everyone**. Guests can always see their own comments. ### Comment reactions React to any comment with emojis by clicking the reaction icon below it. ### Commenting tips * Stay focused on the task - save general discussions for process-level comments * @mention specific people when you need answers * Use **bold** for key points or deadlines * Include context: "Updated vendor list (see attachment)" beats just "Updated" ### Request task status Click the three-dots menu (**...**) on a task and select **Request Status**. Tallyfy posts a comment that @mentions all assignees, asking for a status update. - **[Send email reminders](https://tallyfy.com/products/pro/tracking-and-tasks/tasks/how-can-i-send-email-reminders-in-tallyfy/)**: Tallyfy lets you instantly send manual email reminders to all assignees on any active task by clicking the menu icon next to it. This bypasses automatic reminder schedules when someone needs a direct nudge on urgent or stalled work. ## Send email reminders Click the menu icon (**...**) next to any active task and select **Send Email Reminder** to instantly notify all assignees. Tallyfy sends the email to every assigned [member](/products/pro/documenting/members/) and [guest](/products/pro/documenting/guests/) - except you (the sender). Sometimes Tallyfy's automatic reminders aren't enough. Urgent deadline? Someone stuck? A manual reminder gives people a direct nudge. ### How to send a manual email reminder ### Key details about manual reminders * They're sent immediately - no delay * All assigned members and guests receive the email, except the person who triggered the reminder * These bypass daily digest and reminder frequency settings - but won't reach members who've turned off all emails entirely * This works for both process tasks and standalone (one-off) tasks * Don't overdo it. Nobody likes being nagged To adjust your automatic reminder settings, see [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/)**: Tallyfy's advanced task options in template steps control behaviors like auto-launching linked processes, requiring all assignees to sign off, restricting task completion, firing webhooks, managing guest permissions, and tagging steps. ## Use advanced task options in templates The **Advanced** tab in your [template](/products/pro/documenting/templates/) step editor controls how tasks behave when processes run. You'll find these settings when editing any step. Here's each option: * **Launch another process when this task is complete**: Switch **ON** to automatically start a different process from another template when someone completes this task. You can launch it as a separate process or inject its tasks into your current process. See the [Launch another process guide](/products/pro/launching/launch-process-when-task-is-completed/). * **All assignees must complete this task**: Turn **ON** when you need every assignee's individual sign-off. The task won't move forward until everyone marks it complete. When enabled: * A **lock icon** appears next to assignees - only they can complete the task * A **completion counter** ("2 of 4 completed") tracks progress * 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 like members *This works with Task and Approve/Reject steps, but not with Expiring or Email steps.* * **Assign launcher automatically**: Controls what happens when nobody's assigned to a step. * **ON**: The person who launches the process gets the task automatically * **OFF**: The task stays unassigned until someone claims it or gets assigned :::warning[Group assignment behavior] If a group is assigned to this step and "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. Turn this OFF for group-assigned steps if you don't want that. ::: * **Task is mandatory**: Prevents tasks from being removed at launch. :::note[Deprecated setting] This option still appears but it's deprecated. It's kept for older templates that rely on it. ::: * **Only assigned members can complete or edit this task**: When **ON**, only assigned people can complete or edit this task. Good for sensitive tasks where you need strict control. :::note[Admin override] Admins bypass this restriction - they can always edit tasks. ::: ![Only assigned members can complete setting in Tallyfy](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-only-assigned-can-complete.png) * **Emit webhook when completed**: Switch **ON** to fire a [webhook](/products/pro/integrations/webhooks/) when this task is completed. Useful for notifying external systems like CRMs. * **Prevent guests from making or seeing comments**: When **ON**, [guests](/products/pro/documenting/guests/) can't see or add comments on this task. They can still complete it. :::note You can hide individual comments from guests even when this is **OFF**. ::: * **Unique step alias**: A permanent ID for your step that never changes. You'll need this for API [integrations](/products/pro/integrations/) or webhooks - it's how external systems reliably reference this specific step. * **Tags**: Label individual tasks for filtering. These step-level tags are separate from process tags. Filter your task views by categories like "urgent", "finance", or whatever makes 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/)**: Tallyfy lets you create standalone one-off tasks with a deadline and assignee by clicking + Create. No template needed, making them perfect for urgent work and follow-ups that don't fit standard processes. ## Create a one-off task Click **+ Create** and choose **Create task** to make a standalone to-do with a deadline and assignee - no [template](/products/pro/documenting/templates/) needed. One-off [tasks](/products/pro/tracking-and-tasks/tasks/) in Tallyfy are independent action items. Use them for urgent work, follow-up actions, or anything that doesn't fit a standard process. ### When to use one-off tasks Got a quick request that doesn't fit your standard processes? One-off tasks let you track it in Tallyfy without building a whole template. Follow-ups, document reviews, unexpected requests - they all work here alongside your process-based workflows. - **Name**: A clear title for the task (up to 600 characters). - **Type**: Pick a task type - Regular works for most things, but you've also got Approve/Reject, [Expiring](/products/pro/tracking-and-tasks/tasks/what-types-of-tasks-can-i-create-with-tallyfy/) (auto-completes at deadline to prevent [task debt](/products/pro/tutorials/how-to/how-to-avoid-task-debt/)), Email, and Auto-Send Email. - **Description**: Instructions or context the assignee needs. - **Assignee**: Who's doing this? You can assign members, groups, or guests. - **Deadline**: Required. When the task must be done. - **Start time**: Optional. When work should begin. - **Form fields**: Add [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) to collect data on completion. - **Advanced**: Link this task to a running process or template, add tags, set a webhook, or toggle settings like "everyone must complete." :::note[Start time vs deadline] - **Start time**: When someone should start working. It's guidance only - not enforced. - **Deadline**: When it must be done. Miss this and the task shows as overdue. ::: ![Task creation form with details filled in](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-step3.png) ## What should I learn next? - [Complete or reopen tasks](/products/pro/tracking-and-tasks/tasks/how-can-i-complete-or-reopen-tasks-in-tallyfy/) when things need a second look - [Create subtasks](/products/pro/tracking-and-tasks/tasks/how-to-create-and-use-subtasks/) to break work into smaller pieces - Use the [Tasks view](/products/pro/tracking-and-tasks/tasks-view/) to manage all your tasks in one place - **[Create and use subtasks](https://tallyfy.com/products/pro/tracking-and-tasks/tasks/how-to-create-and-use-subtasks/)**: Tallyfy's Checklist form field lets you break a single task into smaller, checkable subtasks. Configure completion rules (no validation, at least one, or all items required) to track granular actions within a step and control how much must be done before moving on. ## Use the checklist field to create subtasks The **Checklist** [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) type breaks down any task into smaller, trackable subtasks. It's perfect when a single step has multiple actions that need tracking. When you add a Checklist field to a task: - You create a list of checkable items within the parent task - Users check off each item as they go - You control the completion rule - no validation, at least one item, or all items checked ### How do I create checklist subtasks in a template? ### How do checklist completion rules work? Tallyfy gives you three options for when a checklist counts as complete: * **No validation**: The checklist doesn't block task completion. Users can check items optionally. * **At least one item must be checked**: The task can't be completed until at least one box is checked. Good when you're offering choices. * **All items must be checked**: Every single box must be checked. Use this when all subtasks are mandatory. ### How do I complete checklist subtasks when running a process? ![Completing checklist subtasks in a Tallyfy task](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-complete-subtasks.png) ### Best practices for checklists * **Be specific**: Each item should spell out exactly what needs doing * **Keep it manageable**: 3-7 items per checklist works best * **Start with action verbs**: "Verify ID", "Upload document" - not "ID verification needed" * **Order matters**: Put items in the sequence people will actually do them * **Pick the right rule**: Think about whether you need everything checked or just some items * **Add guidance text**: A brief description helps people understand what's expected ### Example checklists **QA Check:** ```text - Check spelling - Verify links - Test on mobile ``` **Onboarding:** ```text - Send welcome pack - Schedule intro meeting - Grant system access ``` - **[Report blockers and improvement feedback](https://tallyfy.com/products/pro/tracking-and-tasks/tasks/how-to-report-and-resolve-issues-in-tallyfy/)**: Flag problems on tasks by posting issue comments that block completion and notify assignees. Resolve issues with a required explanation, filter processes with unresolved problems, and suggest template improvements for future runs. ## Reporting and resolving issues Report a problem on any task by checking **Report issue** in the comment area, typing your description, and posting. Everyone assigned to the task gets notified. To resolve it later, check **Resolve issue** and add a comment explaining the fix. A task with an unresolved issue can't be completed until the issue is resolved. If the task was already completed, reporting an issue automatically reopens it. ### Report an issue on a task ### Resolve an issue Anyone involved with the task can resolve a reported issue: ### Find processes with unresolved issues --- ### Suggest template improvements You can add improvement comments directly on template steps to suggest changes for future processes. #### Add improvement comments These comments attach to the template step itself - they aren't tied to any specific running process. #### View improvement comments #### Act on improvement comments Template owners and 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/)**: Pre-fill form fields with static text, dynamic variables from earlier steps, or system values like today's date. Users spend less time retyping and make fewer errors, while still being free to change any pre-filled value. ## What is default content in form fields? Default content 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. You can use static text, dynamic [variables](/products/pro/documenting/templates/variables/), or system-generated values like today's date. Users can still change these pre-filled values whenever they need to. ### Why use default content? - **Faster completion** - less time retyping common information. - **Fewer errors** - consistent formatting and fewer typos. - **Dynamic data** - [variables](/products/pro/documenting/templates/variables/) pull in relevant data from earlier steps automatically. - **Smart selections** - pre-select the most common options for dropdowns and radio buttons. ## Which field types support default content? 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) - **Static text** - pre-fill with standard phrases, instructions, or 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, multiselect) - **Default selections** - pre-select the most common option. - **Multiple defaults** - for multiselect fields, you can pre-check several items at once. ### Date fields - **Current date** - sets to today's date when the form opens. - **Specific date** - set a fixed date value. - **Variable dates** - pull date values from earlier form fields. ### Field types that don't support defaults These field types can't have default values - Tallyfy automatically disables the option for them: - **File upload** - can't pre-populate files. - **Table** - can't pre-fill table rows, though you configure column headers during setup. - **Assignee picker** - can't pre-select users here, but you can set default assignments at the step level instead. ## How to configure default content ### Setting defaults for text fields ### Setting defaults for dropdown and radio buttons ### Setting defaults for multiselect fields ### Setting default dates ## Using variables in default content [Variables](/products/pro/documenting/templates/variables/) pull information from other parts of your process into default values. ### Variable types available **Form field variables** - grab data entered in earlier steps: - Example: `{{customer_name}}` pulls in the customer name from a previous field. **Kick-off form variables** - data entered when the process started: - Example: `{{request_type}}` shows the type selected in the kick-off form. **System variables** - Tallyfy generates these automatically: - `{{DATE}}` - the date when the process was launched - `{{TEMPLATE_NAME}}` - the name of the template being used ### Variable usage examples **Customer communication:** ``` Dear {{customer_name}}, Thank you for your {{request_type}} request submitted on {{DATE}}. We will process this within 5 business days. ``` **Reference numbers:** ``` {{TEMPLATE_NAME}}-{{DATE}}-{{customer_id}} ``` **Follow-up tracking:** ``` Follow up with {{customer_name}} by {{deadline_date}} ``` ## Best practices - Pick the options people actually select most often for dropdown and radio button defaults. - Pre-fill text fields with real examples or formats your team can use directly. - Think of defaults as suggestions, not rules. If everyone's changing a default, it's the wrong default. - Mix static text with variables for consistency and personalization. - **Internal forms** - use shortcuts and abbreviations your team understands. - **External forms** - provide clear, spelled-out options for customers. - Review your defaults periodically - processes change over time. ## Common use cases ### Customer service requests - **Default priority** - set to "Medium" since most requests aren't urgent. - **Default category** - pre-select the most common ticket type. - **Response template** - pre-fill a greeting with the customer's name using variables. ### Approval workflows - **Default reviewer** - match the reviewer to the request type. - **Approval notes** - give reviewers a template so feedback stays consistent. ### Project initiation - **Project prefix** - combine `{{TEMPLATE_NAME}}` + `{{DATE}}` for automatic project codes. - **Author information** - pull requestor details from the kick-off form using variables. - **Version numbering** - start at "v1.0" for consistency. - **[Scanner and RFID integration for form fields](https://tallyfy.com/products/pro/tracking-and-tasks/tasks/scanner-and-rfid-integration/)**: Barcode scanners and RFID readers in keyboard wedge mode already work with Tallyfy form fields by typing scanned data directly into any focused field. No special drivers or plugins needed for workflows like warehouse receiving, quality control, and asset management. ## How scanners and RFID readers can work with Tallyfy form fields Most barcode scanners and RFID readers use keyboard wedge mode - they act like a keyboard and type scanned data directly into whatever field has focus. This means they already work with Tallyfy's form fields without any special integration. :::note Tallyfy doesn't yet have built-in scanner detection or scanner-specific features. The approach described here uses your scanner's standard keyboard emulation mode, which works with any web application including Tallyfy. ::: ## Keyboard wedge mode (works today) Any scanner in USB HID (Human Interface Device) mode can fill Tallyfy form fields right now. Here's how: 1. Set your scanner to USB HID Keyboard mode (most scanners default to this) 2. Configure it to send an Enter or Tab keystroke after each scan 3. Click into a Tallyfy text or number form field 4. Scan your barcode or RFID tag - the data appears instantly Quick test: open any text editor and scan something. If text appears, your scanner will work with Tallyfy. ## Compatible hardware These scanner types work with Tallyfy through keyboard wedge mode: - **USB barcode scanners** - any HID-compatible model (the vast majority of USB scanners) - **Bluetooth scanners** - paired to your computer or mobile device - **RFID readers** - those that support keyboard wedge output - **2D/QR code scanners** - work the same as 1D barcode scanners ### Recommended scanner settings Check your scanner's manual for these settings: - **Interface mode**: USB HID Keyboard or Bluetooth HID - **Suffix character**: CR (Carriage Return/Enter) or Tab - **Inter-character delay**: 5ms if you see dropped characters - **Prefix**: optional, but helpful for identifying the scan source ## Practical use cases ### Warehouse receiving 1. Open a receiving process in Tallyfy 2. Scan the pallet barcode into the Pallet ID field 3. Scan each item into the items list 4. Scan the storage location QR code into the location field ### Quality control checkpoints 1. Scan the product serial number into the inspection form 2. Scan PASS or FAIL QR codes at each checkpoint 3. Scan the inspector badge to record sign-off ### Asset management Scan an asset tag to look up its record. Scan a location QR code to update where the asset is. This works well for IT equipment, tools, or medical devices. ## Why scanning beats manual entry **Speed** - a scan takes under a second. Typing a 12-digit code takes 5-10 seconds. **Accuracy** - scanners don't make typos. With long alphanumeric codes, scanning removes transcription errors entirely. **Audit trail** - each scan creates a timestamped form field entry you can trace back. ## Common questions ### Will my existing scanner work? If it types text into Notepad when you scan, it'll work with Tallyfy form fields. ### Do I need special software? No. Keyboard wedge scanners need no drivers, plugins, or extra software. ### What about RFID tags? RFID readers that output in keyboard wedge mode work exactly like barcode scanners. Tap the tag, data appears in the focused field. ### How do I prevent scanning into the wrong field? Click the correct field before scanning. Configuring your scanner to send a Tab suffix after each scan can auto-advance to the next field. ## Preparing your workflows for scanning **Test your hardware** - confirm your scanners work in HID mode by scanning into a text editor first. **Design for scanning order** - arrange form fields in the same sequence your workers physically scan items. **Standardize barcode formats** - consistent prefixes (like "EMP" for employees, "SKU" for products) help workers identify what they're scanning. - **[Paste cells into a Tallyfy table](https://tallyfy.com/products/pro/tracking-and-tasks/tasks/paste-cells-tallyfy-table/)**: Import data from Excel or CSV files directly into a Tallyfy Table form field. Columns are matched by position, and the first row is skipped as a header. ## Import data from Excel/CSV into a Table form field You can import data from an Excel or CSV file directly into a Tallyfy **Table** [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/). You don't need to retype anything. ### What should I know before importing? - **Column order matters**: Data from your spreadsheet is mapped to the Tallyfy table by column position: the first column in your file maps to the first column in the table, second to second, and so on. Make sure your spreadsheet columns are in the same order as the Tallyfy table columns. - **Supported file types**: Tallyfy accepts .xlsx, .xls, and .csv files. - **First row is skipped**: Tallyfy treats the first row of your file as a header and won't import it as data. ### How do I import data into the Tallyfy table? Tallyfy adds the rows from your file automatically. It doesn't fill in blank cells from your spreadsheet. - **[Task assignment options](https://tallyfy.com/products/pro/tracking-and-tasks/tasks/task-assignment-guide/)**: Tallyfy lets you assign tasks to members, groups, or external guests via email. Automation rules can dynamically reassign tasks based on form field values or step completion status. ## Task assignment in Tallyfy Tallyfy supports three main assignment types: members, groups, and guests. You can assign one or many people to any task. ### Assignment types #### Member assignment Assign tasks to specific people in your organization: - **Individual** - pick a specific person by name - **Multiple assignees** - assign several people, optionally requiring all of them to complete the task (using the `everyone_must_complete` setting) - **Assign to process starter** - automatically assign to whoever launched the process (the `assign_run_starter` option on a step) #### Group assignment Assign tasks to a group instead of individual people. When you assign a group, all members of that group become assignees. You can also set `max_assignable` to limit how many people from the group can pick up the task. #### Guest assignment Assign tasks to people outside your organization by entering their email address. Tallyfy sends them a link to complete their task. They don't need an account. Guests can fill out form fields and submit data on tasks assigned to them. ### Assigning tasks in templates When editing a template step: 1. Select a step in your template 2. Open the assignment dropdown 3. Choose the assignment type (member, group, or guest) 4. Pick specific assignees 5. Optionally configure `everyone_must_complete`, `can_complete_only_assignees`, or `max_assignable` ### Reassigning tasks in active processes You can change task assignees in a running process by editing the task's owners. Admins can reassign any task. To reassign: 1. Open the task in the active process 2. Edit the assignees 3. Select the new assignee (member, group, or guest email) 4. Save changes Tallyfy automatically notifies newly added assignees by email. ### Automation rules for assignment Tallyfy's automation rules (automated actions) can change task assignments based on conditions. The available assignment actions are: - **assign** - add assignees to a step - **assign_only** - replace all current assignees with new ones - **unassign** - remove specific assignees - **clear_assignees** - remove all assignees from a step Conditions can be based on form field values or step completion status. This lets you route tasks dynamically. For example, you can assign a review step to a specific manager based on a dropdown selection in a previous step. ### Bulk reassignment When you're removing a user from your organization, Tallyfy's `ReassignInformation` service lets you reassign all their templates, steps, processes, and tasks to another user in one operation. You can also update multiple task assignments at once within a single process using the bulk update feature. ### Troubleshooting assignment issues | Issue | Solution | |-------|----------| | Unassigned tasks | Set default assignees on template steps or use `assign_run_starter` | | Assignee unavailable | Use group assignment so other group members can pick up the task | | Guest can't access task | Verify the guest email is correct and resend the task notification | | Too many people assigned | Set `max_assignable` on the step to limit assignees | ### Example assignment strategies **Approval workflow** - Submission: assigned to a group (e.g., department members) - Review: assigned to a specific person (e.g., department manager) - Final approval: assigned to an executive (direct assignment) **Customer onboarding** - Document collection: assigned to the customer (guest by email) - Verification: assigned to an onboarding specialist (direct) - Account setup: assigned to the IT group (group assignment) - Welcome call: assigned dynamically via an automation rule based on a form field value - **[Manually show or hide tasks](https://tallyfy.com/products/pro/tracking-and-tasks/tasks/manually-show-hide-tasks/)**: Tallyfy lets you manually hide or show incomplete tasks in a running process using the three-dot menu on any task card. This helps when mid-process changes leave irrelevant tasks visible that automation rules didn't cover. ## How to manually control task visibility Click the **three dots (⋮)** menu on any non-completed task and select **Hide This Task** or **Show This Task** to control visibility in running processes. This is useful when someone changes a form selection mid-process - say, switching from "Corporation" to "LLC" - and now irrelevant tasks are cluttering the view. Or when your [automation rules](/products/pro/documenting/templates/automations/) don't cover this specific scenario. :::note You can't hide or show completed tasks or one-off (standalone) tasks. The option only appears for incomplete tasks within a running process. ::: ## When to use manual show/hide - **Mid-process pivots** - a customer switches from "New Installation" to "Upgrade" after starting the process - **Automation gaps** - your rules show tasks that shouldn't appear in this scenario - **One-time exceptions** - a compliance task isn't needed for this specific client, but you can't remove it from the template - **Testing** - you're walking through different process paths without launching separate test runs ## How to hide a task The task vanishes from the active view but Tallyfy keeps it in the process - nothing gets deleted. ## How to show a hidden task ## Important considerations ### Hidden task data is preserved Hidden tasks keep everything - form data, file attachments, comments, and assignments. When you show a task again, it's exactly as it was. Internally, Tallyfy sets hidden tasks to an `auto-skipped` status rather than deleting them. ### Manual overrides beat automation If you manually hide a task, it stays hidden even when automation conditions change. For example: your automation would normally show a task when "Priority = High". You manually hid it. Someone changes priority to High. The task stays hidden. You'll need to manually show it again. ### How hiding affects your process When you hide a task, 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, Tallyfy now tracks 9. Hidden tasks don't count against deadlines either. ## Best practices **Add comments when hiding or showing tasks.** Tallyfy prompts you with a comment dialog for a reason. Six months later when someone asks "Why is the compliance task missing?" you'll have an answer. **Review hidden tasks periodically.** They're easy to forget. If you're repeatedly hiding the same task type, that's a sign to update your template's [automation rules](/products/pro/documenting/templates/automations/) instead. **Use hiding for exceptions, not everyday scenarios.** If a simple automation rule update would solve the problem permanently, do that instead of manually hiding tasks each time. ## Example scenario Your intake form asks "Business Type" - Corporation, LLC, Partnership, or Sole Proprietor. Each choice triggers different tasks via automation. A client selects "Corporation" and moves forward. Corporate filing tasks appear. Ten minutes later: "Actually, we're an LLC." They change their selection. The LLC tasks show up, but the corporate tasks remain visible too. What to do: 1. Hide the corporate filing tasks using the three-dot menu 2. The LLC tasks are already visible thanks to automation 3. Add a comment: "Client switched from Corp to LLC during intake" Your team now sees only LLC-relevant tasks. If the client changes their mind again, those hidden tasks are one click away. - **[Escalating overdue tasks](https://tallyfy.com/products/pro/tracking-and-tasks/tasks/task-escalation-for-overdue-items/)**: Tallyfy escalates a late task by pairing it with an expiring step that falls due a little later, then firing an automation the moment that step expires. Date the expiring step from the process launch, never from the step it watches, or the escalation never fires at all. ## Chasing a step that misses its deadline Tallyfy has no account-wide escalation switch. You build escalation onto one specific step instead, using a pair of steps: the real one, plus a second step that expires a little later. When the second one expires, an [automation](/products/pro/documenting/templates/automations/) fires and does whatever you told it to do to the real step. Building it per step is the point. In a 40 step process you attach escalation to the two or three steps where being late actually costs you something, so nobody gets buried in alerts about the other 37. :::note[What counts as overdue] A task is overdue once its **deadline** passes, which is when the work should be **finished**. That's different from its start time, which only suggests when to begin. Only the deadline decides overdue status. ::: ### Why an expiring step is the trick Tallyfy automations react to a step changing state. Someone completes it, approves it, rejects it, acknowledges it. There's no "when a deadline passes, do something" trigger sitting in the list for you to pick. One step type gets around that. An [Expiring step](/products/pro/tracking-and-tasks/tasks/what-types-of-tasks-can-i-create-with-tallyfy/) completes itself the moment its deadline arrives, with nobody touching it. That makes it the only clock in Tallyfy you can hang a rule on. Set one to expire shortly after the real work was due, and you've built yourself a deadline trigger. ### The pattern, with a real example Say your month-end close template has this step: - **Post month-end journal entries**, due 5 days after launch, assigned to Jelena. You add a second step beside it: - **Escalate journal entries**, step type **Expiring**, due 6 days after launch. Nobody needs to be assigned to it. Then one rule: **IF** "Escalate journal entries" is expired, **THEN** add Jelena's manager as an assignee on "Post month-end journal entries". On day 6 the expiring step completes itself, the rule fires, and the manager lands on the task. If Jelena posted the entries on day 4, nothing happens at all. The gap between day 5 and day 6 is your grace period. You set it purely by choosing the expiring step's date. Want three days of slack instead of one? Date it day 8. ### How to set it up You'll need rights to edit the template. To check your work, launch a test process and deliberately leave the real step alone. Come back after the expiring step's deadline and you should see the action land on the real task. ### Set the expiring step's deadline from the process launch :::caution[This one setting decides whether escalation works at all] In the expiring step's **Timings** row (on the **Basics** tab), choose **Process Launch**. Don't choose **Another Step**. Picking **Another Step** is the intuitive move. You're watching "Post month-end journal entries", so dating the escalation "1 day after Post month-end journal entries" reads like the obvious answer. It isn't. Tallyfy deliberately holds back a step whose deadline depends on another step until that other step is finished. So your escalation sits and waits for the work to be done, which is the exact moment you no longer need it. **Do this:** expiring step due 6 days after **Process Launch**, real step due 5 days after **Process Launch**. **Not this:** expiring step due 1 day after **Another Step**, pointed at "Post month-end journal entries". ::: We ran two identical processes side by side and left the real work undone in both: | The expiring step was dated from | What actually happened | |---|---| | **Process Launch** | It expired on time and the manager was added. Escalation worked. | | **Another Step** | It never expired at all, even after a full extra cycle. No escalation. | If you build this pattern and nothing ever happens, this is almost always the reason. ### Any automation action can hang off it Adding a manager is the most common choice, not the only one. "Is expired" is an ordinary condition, so every [automation action](/products/pro/documenting/templates/automations/actions/) is available to you: - **Change who's assigned.** Add people to the step, replace everyone on it, or clear the assignees. See [assignment actions](/products/pro/documenting/templates/automations/actions/asignment-actions/). - **Change a deadline.** Push the due date out or pull it in. See [deadline actions](/products/pro/documenting/templates/automations/actions/deadline-actions/). - **Show or hide a step.** Reveal a normally hidden "Explain the delay" step only when something runs late. See [visibility actions](/products/pro/documenting/templates/automations/actions/visibility-actions/). - **Reopen a completed step.** Send work back for another pass. See [status actions](/products/pro/documenting/templates/automations/actions/status-actions/). - **Fire a webhook.** A webhook (an automatic message Tallyfy sends to another system the instant something happens) hands the event to a tool you already run. See [webhooks](/products/pro/integrations/webhooks/). :::tip[Webhooks give you the wording] The standard assignment email does the job, but it's still a standard assignment email. A webhook hands the event to your own system, so your team writes the escalation message itself and sends it wherever people already look, whether that's email or chat. That's usually a kinder note than an automatic one, and people read it. ::: ### It cancels itself when the work gets done There's nothing to remember and nothing to switch off. Finish the real step before the expiring step's deadline and no escalation happens. Here's why. Tallyfy won't apply an automation action to a step that's already complete. The expiring step still expires and the rule still fires, but the action has nothing left to do, because there's nobody left to chase. We tested that with two identical processes. One was left alone, one had the real work completed early. The one left alone got the manager added. The one where the work was done didn't. ### How quickly escalation happens Tallyfy checks for expiring steps every 5 minutes, so escalation arrives within about five minutes of the deadline rather than on the exact second. For chasing a late journal entry that's plenty. If you need something to react in seconds, this pattern isn't the right tool. ### A simpler condition is on the way A condition that reacts to a deadline passing, with no expiring step involved, has been built and is in review. It hasn't shipped yet, and we're not putting a date on it. Until it does ship, the expiring step pattern above is how escalation works in Tallyfy. ## Catching late work in general Escalation is for the few steps where lateness really hurts. For everything else, two things already help: - **Digest emails** list tasks that are due soon or overdue. They go out at 6 AM in each person's local timezone, and everyone picks their own days in [email notification settings](/products/pro/settings/personal-settings/how-can-i-manage-email-notifications-in-tallyfy/). - **Overdue filters** narrow a list down to just the late work. In the [Tasks view](/products/pro/tracking-and-tasks/tasks-view/), filter on **Task State** and pick **Overdue**. The [Tracker view](/products/pro/tracking-and-tasks/tracker-view/) does the same thing one level up, showing you which whole processes are behind. You can also comment on any late task to ask for an update, or watch a process to get notified about every change to it. Watching won't ping you at the moment a task turns overdue, though. ## Following up when something is late Research shows that threat-based reminders ("this task is overdue!") backfire. They dent motivation and make performance worse. Asking what's in the way works better. - **Ask about blockers first.** "What's holding this up?" gets you further than "Why isn't this done?" - **Say why it matters.** "The auditors need this by Friday" gives someone a reason, not just a date. - **Offer rather than order.** "You might want to try..." lands better than "You must...". - **Be consistent.** Check for late work on a regular rhythm instead of at random. - **Write it down.** Use [comments](/products/pro/tracking-and-tasks/tasks/how-can-i-manage-comments-in-tallyfy/) on the task so the conversation stays with the work. - **Set a new date you believe in.** If you're extending a deadline, pick one that can genuinely be met. :::tip[The point of a follow-up] A good follow-up removes an obstacle. A weak one just points out that something is late. ::: ## Stopping the pile-up in the first place Escalation is a repair job. These four habits stop the damage instead, and they beat chasing people every month. - **Use expiring steps for FYI items.** They complete themselves at the deadline, so announcements and optional reading never turn into overdue clutter. - **Bundle small work into one step.** One step with five form fields beats five separate steps that can each go late. - **Set deadlines you've actually hit before.** Base them on how long the work really takes, not on the best case. - **Drop steps that are always late and never matter.** If a step goes overdue every month and nothing bad follows, it isn't really a step. There's more in the guide on [how to avoid task debt](/products/pro/tutorials/how-to/how-to-avoid-task-debt/). - **[Types of form fields](https://tallyfy.com/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/)**: Tallyfy form fields collect user input on kick-off forms and individual tasks. Types include short text, long text, dropdowns, checklists, radio buttons, dates, file uploads, tables, and assignee pickers. ## Form field types in Tallyfy Form fields let Tallyfy processes collect user input that can change how the process flows. Add them to the **Kick-off Form** (filled before the process starts) or to individual tasks. :::tip[Form fields create variables] Input collected through form fields becomes data that processes use to modify their flow via [variables](/products/pro/documenting/templates/variables/) and [automations](/products/pro/documenting/templates/automations/). ::: :::note[Required vs. optional] You can mark most fields as required or optional. Checklists use validation rules instead. ::: :::note[Guidance text] All field types support adding help text (Guidance Text) below the label to guide users. ::: ### How do different field types work? #### Short text * Single line for brief input (up to 200 characters). * **Options**: Validation rules (numeric, email, URL, alpha, alpha_num, alpha_dash), min/max length, prefix/suffix (e.g., $, kg). * **Tip**: Store [file request links](mdc:products/pro/integrations/document-management/file-request-links/) from your document management system for secure external file collection. ![Short text form field in Tallyfy](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-short-text-field.png) #### Long text * Multi-line input for detailed responses (up to 30,000 characters). * **Options**: Enable rich text formatting (bold, lists) via the WYSIWYG editor toggle. * Use for descriptions, notes, or feedback. ![Long text form field in Tallyfy](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 apps**, formatting is stripped to prevent broken HTML. Use the formatting toolbar to reapply styles after pasting. **Preserving complex formatting**: - **Option 1**: Use "Show HTML" toggle to paste raw HTML - **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 ::: #### Dropdown list * Pick **one** option from a list. Useful for branching workflows (e.g., selecting a department determines approvers). * **Options**: Define list items, set default, add prefix/suffix. * **Important**: When reordering options in the template editor, click save explicitly. Changes won't persist if you leave the page without saving. ![Dropdown list form field in Tallyfy](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-dropdown-list.png) #### Checklist * Check **one or more** items from a list. * **Options**: Define list items, set defaults, validation (require 'at least one' via the required flag, or 'all items' via the must-all-checked setting). * 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/). ![Checklist form field in Tallyfy](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-checklist-field.png) #### Radio buttons * Pick **only one** option. Requires at least 2 options. * **Options**: Define list items, set default. * Great for Yes/No decisions or priority levels that branch the process. ![Radio buttons form field in Tallyfy](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-radiobuttons-field.png) #### Date * Pick a date (and optionally time) from a calendar. The `collect_time` toggle controls whether time selection appears. * **Options**: Set a default date (e.g., today, today + 7 days). * Use for deadlines, start dates, meeting dates, and other scheduling. * **Integration note**: When setting date values via the [API](/products/pro/integrations/open-api/) or [middleware](/products/pro/integrations/middleware/) (Zapier, Make, etc.), use ISO 8601 format: `YYYY-MM-DDTHH:mm:ss.SSSZ` (e.g., `2026-03-18T00:00:00.000Z`). Dates display in each user's preferred [date format](/products/pro/settings/personal-settings/personalization-settings/). ![Date and time picker form field in Tallyfy](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-datetime-field.png) #### File upload * Upload file(s) up to 100MB each[^2]. * **Options**: Set as required. * Use for collecting docs, images, or reports. Supports multiple file uploads in a single field. * **Alternative**: For sensitive or larger files, use [file request links](mdc:products/pro/integrations/document-management/file-request-links/) from your document management system. ![File upload form field in Tallyfy](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-file-upload-field.png) #### Table * Define columns, and users add rows of data. Default values aren't supported for tables. * **Adding columns**: In the template editor, click **Add New Column** to define the structure. * **Using in tasks**: Users click **Add Row** to enter data into your defined table. * **Using with variables**: 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**: Create [automation rules](/products/pro/documenting/templates/automations/) that check if a specific column **Contains** a certain value. #### Assignee picker * Select a Tallyfy member, guest, or group. * **Options**: Set as required. On a kickoff form, you can also set "Default to guest" so the person submitting a public kickoff is auto-assigned to this field on launch - useful for self-service onboarding. * Use when the person doing a later task needs to be chosen during the process. ![Assignee picker form field in Tallyfy](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-assignee-picker.png) :::important[Assignee picker captures data but doesn't auto-assign] **The assignee picker captures who was selected but does NOT automatically reassign tasks.** To use the selected assignee, 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 → Automation assigns Step 2 to that 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** (e.g., Unit Price x Quantity = Total). **Workarounds**: 1. **External calculation** - Users calculate externally and enter the result 2. **Guidance text** - Provide calculation instructions in the field's guidance text 3. **Automation rules** - Route to different steps based on entered values 4. **Webhooks/API** - Send data to external calculation services 5. **Multiple fields** - Collect components separately (price, quantity) and calculate in reporting ::: :::tip[Deleting form fields with rule dependencies] **Can't delete a form field?** If it's referenced in automation rules in other steps, you'll see: "Cannot delete a form field that is being used in a rule in other steps." Delete or modify those rules first, then delete the field. ::: ### What other field settings are available? Most fields have these settings: * **Name**: The field label (the question your process asks). * **Guidance**: Optional help text below the label. Add this in the **Advanced** section of field settings in the template editor. It appears in italics below the field name when the task is active, and any URLs become clickable links. * **Field Alias[^1]**: Auto-generated internal ID based on the *first* name you give the field. It **doesn't change** even if you rename the field later, so automations and integrations using the alias keep working. * **Required**: Whether this field must be filled before the task can be completed. * **Default Value**: Pre-fill a value (can use variables for text fields). Not available for table, file upload, or assignee picker fields. See [Set default content for form fields](/products/pro/tracking-and-tasks/tasks/how-to-set-default-content-for-form-fields/) for details. ![Toggle for required and not-required form fields in Tallyfy](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 - **[Step types](https://tallyfy.com/products/pro/tracking-and-tasks/tasks/what-types-of-tasks-can-i-create-with-tallyfy/)**: Tallyfy has two task categories and five step types. Process tasks are steps inside templates that become active when a process runs. One-off tasks are standalone to-dos. The five types cover standard work, approvals, expiring items, and email sending. ## Types of tasks in Tallyfy Tallyfy has two categories of tasks - process tasks and one-off tasks - each supporting five step types. ### Process steps vs one-off tasks * **Process Steps/Tasks**: These are defined within a [template](/products/pro/documenting/templates/) as "Steps," and they become "Tasks" when the [process](/products/pro/tracking-and-tasks/processes/) runs. * **One-Off Tasks**: Standalone to-dos that aren't linked to any template. * [Create one-off tasks individually](/products/pro/tracking-and-tasks/tasks/how-to-create-a-one-off-task-in-tallyfy/) * [Add them to a running process](/products/pro/tracking-and-tasks/processes/edit-processes/how-can-i-add-tasks-to-active-processes-on-tallyfy/) as ad-hoc tasks * Link a one-off task to a specific template or process :::tip[Adding ad-hoc tasks to active processes] You can add ad-hoc tasks to a running [process](/products/pro/tracking-and-tasks/processes/) without modifying the original [template](/products/pro/documenting/templates/). Template creators control this via the **"Can people add one-off tasks to this process?"** toggle in the template editor (default is "Yes"). If it's set to "No," ad-hoc tasks are blocked entirely for that process. ::: ### Five step/task types | Type | Main Button(s) | Must be completed? | Description | |---------------------|--------------------------|--------------------|-------------| | **Task** | COMPLETE | Yes | Standard to-do for most actions (data entry, reviews). | | **Approve/Reject** | APPROVE / REJECT | Yes | For decisions and approvals. Can trigger [Automations](/products/pro/documenting/templates/automations/). | | **Expiring** | ACKNOWLEDGE | No (optional) | Auto-completes at deadline if not acknowledged. Prevents overdue task build-up. | | **Email Draft** | SEND | Yes | Email draft for assignee review/edit before manual send. | | **Email Auto-Send** | SEND RIGHT NOW / (Auto) | Yes | Sends email automatically at deadline, or earlier via **SEND RIGHT NOW**. | #### Task type The standard type. The assignee clicks **COMPLETE** to finish it. #### Approve/Reject type Shows two buttons - **APPROVE** and **REJECT**. Use [Automations](/products/pro/documenting/templates/automations/) to trigger different actions based on the choice. :::tip[Restricting approvals] You can restrict completion to assigned users only by enabling "Only assigned members can complete..." in the task's **Advanced** tab. Admins can always override this setting. ::: #### Expiring type If nobody clicks **ACKNOWLEDGE** by the deadline, the task auto-completes and disappears from active task lists. Great for information sharing without creating [task debt](/products/pro/tutorials/how-to/how-to-avoid-task-debt/). Common uses: - FYI updates that don't require action - Optional resources or training materials - Weekly status reports for awareness - Non-critical announcements Team members get notified and can engage if they want, but the task won't pile up if they don't. #### Email types * **Email Auto-Send**: Write the email in the template. It sends automatically at the deadline unless someone clicks **SEND RIGHT NOW** earlier. * **Email Draft**: Write a draft in the template. The assignee reviews/edits and clicks **SEND** manually. * **Send Chromeless**: Both email types can send without Tallyfy branding. Enable the **"Send Chromeless"** option to send plain emails without the Tallyfy logo, header, and footer - useful when emails should look like standard messages rather than workflow notifications. * **Email Copies**: Assignees receive a copy of sent emails unless they've disabled 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/). ::: - **[Edit tasks](https://tallyfy.com/products/pro/tracking-and-tasks/tasks/edit-task/)**: Edit any task on the fly in Tallyfy. Reassign people, update descriptions with rich text and media, and adjust due dates for standalone tasks and tasks inside running processes. ## Options for editing tasks Edit any [task](/products/pro/tracking-and-tasks/tasks/) in Tallyfy - change assignees, update descriptions, add videos or images, and adjust due dates. This works for both standalone tasks and tasks inside running [processes](/products/pro/tracking-and-tasks/processes/). Someone out sick? Reassign their tasks. Requirements changed? Update the description. Need clarity? Add a video. There's a rich text editor to format descriptions with bullet points, headings, and highlights. ### 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/)**: Add videos to Tallyfy tasks by embedding YouTube or Vimeo links through Insert > Embed URL, or by uploading MP4/WebM/OGG files up to 100MB through Insert > Video. Embedding loads faster and doesn't use storage. ## Add or embed videos in tasks You can add videos to a [task](/products/pro/tracking-and-tasks/tasks/) two ways - embed from YouTube/Vimeo using **Insert > Embed URL**, or upload files directly through **Insert > Video**. Embedding is usually better since it's faster and doesn't use your storage. 1. **Embed from video sites** - Link to videos on YouTube, Vimeo, or similar platforms 2. **Upload video files** - Upload MP4, WebM, or OGG files (up to 100MB) directly to Tallyfy ### Method 1: Embed videos from links (recommended) Embedded videos load faster and don't count against your storage. No file size limits to worry about either. :::tip[Many embed sources supported] Tallyfy's "Embed URL" option works with hundreds of sources beyond just videos - Figma designs, Google Docs, Typeform surveys, and more. ::: ### Method 2: Upload video files For proprietary content or recordings you've just made, upload the file directly. The limit is 100MB per file. Supported formats are MP4, WebM, OGG, and QuickTime. Prefer embedded videos when possible - they load faster and won't use storage space. - **[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 lets you assign people to tasks at three stages: inside a template as defaults, during process launch, or while a process is already running. It also includes settings to auto-assign the launcher and restrict task completion to only assigned members. ## Assigning members and guests to tasks 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 it's already running. ### Assign tasks in a template Set default assignees in your template: These defaults apply every time someone launches the process. You can change them at launch. ### Assign tasks when launching a process Modify assignments during launch: ### Assign or reassign tasks in a running process Change assignments in a running process: ### Unassigned tasks ("nobody assigned") Tasks with no assignees show a generic icon and **"Nobody Assigned"** label. Find them using the **"Assigned to nobody"** filter in the [Tasks view](/products/pro/tracking-and-tasks/tasks-view/). Anyone with permission can claim them or assign them to others. ### "Assign launcher automatically" setting This per-step setting controls what happens when no assignees are configured: * **If ON (default)**: The person who launches the process gets auto-assigned to any step that has no members, groups, or guests assigned. * **If OFF**: Steps with no assignees stay as "Nobody Assigned" after launch. If any assignee is already set - whether a member, group, or guest - this setting doesn't affect that step. ### Restrict task completion and editing Control who can complete or edit tasks: ![Only assigned members can complete task setting](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 built-in rich text editor lets you format text and add images and videos and dynamic variables and reusable snippets across task descriptions and comments while also supporting mailto: links and Gmail compose URLs in HTML mode to let users send pre-filled emails directly from workflow steps. ## Use the rich text editor for tasks and descriptions Tallyfy's rich text editor appears wherever you type text - task descriptions, comments, long text fields, and template descriptions. You can format text, add images, embed videos, and insert dynamic content. ### Basic formatting The toolbar includes: * **Bold**, *Italics*, Underline * Bulleted and numbered lists * **Headings** (H2, H3 - useful for organizing longer content) * Code tags and emoticons ### Dynamic content (variables, snippets) On the right side of the toolbar, you'll find: * **Insert Variable** (**{ }** icon) - pulls in data collected earlier in your process: * **Kick-off form fields** * **Previous step fields** in the same process * **System variables** (`Current TaskID`, `Current ProcessID`) - mainly for technical integrations * See [Using Variables](/products/pro/documenting/templates/variables/how-can-i-use-insert-variables-in-tallyfy/) for details. * **Snippets** - reusable text blocks you can drop in with a click. See [Using Snippets](/products/pro/documenting/templates/snippets/how-can-i-use-snippets-to-simplify-workflow-in-tallyfy/). * **Templates** - link to another template inside your current one, perfect for referencing standard procedures or compliance checklists. ### Media and elements The toolbar also includes these insert options: * **Insert Image** - upload or link to an existing online image * **Upload File** - attach documents, spreadsheets, PDFs, or other files * **Insert Video** - upload video files (MP4, WebM, OGG, up to 100MB). Tip: use **Embed URL** instead for faster loading. More 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** - add a simple table * **Embed URL** - paste links from YouTube, Vimeo, Twitter, Google Maps, and other sites. The content displays inline - no clicking away. * **Page Break** - mainly used in [Document templates](/products/pro/documenting/documents/) ### Pasting content from Word or Google Docs When you paste from Word or Google Docs, most formatting (fonts, colors, fancy layouts) gets stripped. Tallyfy does this to keep everything consistent. Best approach: paste as plain text first, then reformat with the editor buttons. ### How Tallyfy differs from Word * Built for online workflows, not printed documents * Headings (H2, H3) automatically create a table of contents * Your organization's branding applies globally - no per-document formatting needed * Images from Word may appear oversized - resize them after pasting * Instead of saved versions, Tallyfy tracks every change in activity logs showing who changed what and when ### One-click email links using HTML mode You can create mailto: links in task descriptions using HTML mode and [variables](/products/pro/documenting/templates/variables/) to let users send pre-filled emails with a single click. Their default email client opens with subject, recipients, and body already filled in. #### Prerequisites - **HTML authoring** must be enabled in **Settings > Organization > Customization** (by default, only admins can toggle HTML mode - this setting opens it to all users) - Variables set up in earlier steps for dynamic content - Users need a default email client on their device #### Basic mailto: link In HTML mode: ```html Click to send status email ``` #### Using variables in mailto: links Combine mailto: links with Tallyfy variables to pull in data collected earlier: ```html Email customer about order ``` Use `%0A` for line breaks in the email body (URL encoding for a new line). #### Advanced mailto: options Add multiple recipients, CC, and BCC: ```html Request approval ``` #### Common use cases - **Customer notifications** - pre-fill order updates, appointment confirmations, service completions - **Approval requests** - emails with all context for quick approvals - **Status updates** - one-click reports to managers or clients - **Escalations** - urgent emails with relevant case information The email opens in the user's client for review before sending. Nothing gets sent automatically. ### Browser compatibility for mailto: links **Desktop browsers (Chrome, Edge, Firefox):** Full support. Look for the protocol handler icon in the address bar and allow your preferred email service to handle email links. **Safari and mobile browsers:** Limited. Safari on macOS opens the default Mac mail app. Mobile browsers launch native mail apps rather than web email. You'd need an app like Gmail set as the default handler. **Workaround:** If your team uses Gmail, skip mailto: and use Gmail compose URLs instead (see below). ### Mailto: links don't support HTML formatting Per the mailto: specification (RFC 6068), the `body=` parameter only accepts plain text: - No bold, italics, hyperlinks, tables, or images - HTML tags appear as literal text - Use `%0D%0A` for line breaks - Example: `mailto:user@example.com?body=Line%201%0D%0ALine%202` For rich HTML emails, use server-side email sending, a web form backend, or have users format manually after opening. ### Alternative: Gmail compose URLs For teams on Gmail, you can create direct compose URLs that bypass mailto: entirely: ``` https://mail.google.com/mail/?view=cm&fs=1&to=recipient@example.com&su=Subject&body=Message ``` **Parameters:** `to=`, `cc=`, `bcc=`, `su=` (subject), `body=` (plain text, URL-encoded) **With variables:** ```html Email customer via Gmail ``` **Limitations:** Gmail-only, web-only (opens in browser tab), users must be logged into Gmail, plain text body only. **When to use each:** - **mailto:** - universal compatibility across email clients - **Gmail URLs** - when all users use Gmail and you want to avoid handler issues - **Server-side** - when you need HTML formatting, attachments, or guaranteed delivery ### 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 lets you organize active tasks and running processes using two independent folder systems and flexible tags. Group and filter your work quickly across the Tasks and Tracker views. ## Organizing work with folders and tags You can organize work in Tallyfy using two separate folder systems and tags. This page covers the **Task/Process Folders** you'll use in the **Tasks** and **Tracker** views. ### Two folder systems Tallyfy has **two completely separate sets of folders**: 1. **Template Folders** - used *only* in the **Templates** library to organize 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 *active* work (running processes and individual tasks). They're independent systems. For example: * **Template Folder**: `HR Templates` > `Onboarding` * **Process Folders**: `Active Onboardings - Sales Team`, `Active Onboardings - IT Team` ### 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(s)**. 4. Choose an existing folder or create a new one. ![Add task to folder dialog in Tallyfy](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-add-task-to-folder.png) ### Filtering tasks by folder 1. Go to the **Tasks** view. 2. Click **Add Filter**. 3. Select **Folder** as the filter type. 4. Pick the folder you want to view. ![Filter tasks by folder in Tallyfy](https://screenshots.tallyfy.com/tallyfy/pro/desktop-light-filter-task-process.png) ### 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(s)**. 5. Choose an existing folder or create a new one. ### Filtering processes by folder 1. Go to the **Tracker** view. 2. Click **Add Filter**. 3. Select **Folder** as the filter type. 4. Pick the folder you want to view. ### Using tags [Tags](/products/pro/documenting/templates/how-to-manage-templates-and-processes-with-tags/) work alongside folders as flexible labels for tasks and processes. * **Tagging Processes**: Open the process, click the menu, and select **Add Tags**. * **Filtering by Tag**: Use the **Tag** filter in both **Tasks** and **Tracker** views. Tags let items belong to multiple categories at once - a task could be tagged "Urgent" and "Client A". You can't place an item in multiple folders. - **[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 lets you stack filters like status, assignee, tag, and template to narrow down your task list. Sort results by most recent or most delayed to spot overdue work or check specific people's workloads. ## Filters and sorting in the tasks view Tallyfy's **[Tasks View](/products/pro/tracking-and-tasks/tasks-view/)** shows all your [tasks](/products/pro/tracking-and-tasks/tasks/) in one place. Filter and sort this list to find overdue tasks, work assigned to a specific person, or items from a particular template. ### How do I add filters? Click **Add Filter** at the top of the Tasks view. You can stack multiple filters - they work together to narrow your list. Here's what you can filter by: * **Status** - See your 'To Do' tasks (the default), 'Completed', or 'All' * **Assignee** - Find tasks for specific [members](/products/pro/documenting/members/), [guests](/products/pro/documenting/guests/) (by email), groups, or roles * **Task State** - Show what's 'Overdue', 'Due Soon', 'On Time', or has a reported issue * **Tag** - Pull up tasks with specific tags * **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 in a [folder](/products/pro/tracking-and-tasks/tasks-view/how-can-i-add-tasks-to-folders-in-tallyfy/) ![Task filter options in Tallyfy Tasks view](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-filter-task.png) ![Adding a filter to the Tasks view in Tallyfy](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-add-filter-to-task.png) #### Example: See completed work #### Example: Check a guest's workload ### How can I sort tasks? Use the sort dropdown in your Tasks view. Three options: * **Most Recent** - shows tasks with the latest activity first (this is the default) * **Most Delayed** - puts overdue tasks at the top * **Recently Completed** - shows recently finished tasks (only visible when viewing completed tasks) ![Sort options in Tallyfy Tasks view](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-sort-tasks.png) Combine filters and sorting for fast results. Filter by assignee and sort by most delayed to see who's falling behind. Filter by template and sort by most recent to track the latest activity on specific workflows. ### Tracker view - **[Track running 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 gives you a dashboard of every running process in your workspace with status cards, color-coded deadlines, and filtering options to spot overdue or blocked work. ## Track running processes Open the **[Tracker](/products/pro/tracking-and-tasks/tracker-view/)** from the left sidebar to get a high-level view of all running [processes](/products/pro/tracking-and-tasks/processes/) across your Tallyfy workspace. ### What does the Tracker view show? ![Tallyfy Tracker view showing running process cards](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-showcase-tracker-tab.png) Each running process appears as a card showing the process name, source template, current status (On-time, Due soon, or Overdue), tasks completed, next due date, and who's assigned the next task. ### How can I sort and filter processes? * **Sorting** - Use the sort dropdown to order processes by Newest/Oldest, Most Delayed, or alphabetically (A-Z or Z-A). ![Sort dropdown for ordering processes in Tracker view](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-order-processes.png) * **Filtering** - Click **Add Filter** to show only processes matching specific criteria - like assigned person, tags, template, status, type, or folder. See [Customize the Tracker view](/products/pro/tracking-and-tasks/tracker-view/how-to-create-custom-views-in-tallyfy/). ### What do the status colors mean? * **On-time** - Running normally, no deadlines missed. * **Due soon** - One or more tasks are due within 24 hours. * **Overdue** - A task deadline hasn't been met. * **Problem** - Someone's reported a blocker on a task. - **[Check process activity](https://tallyfy.com/products/pro/tracking-and-tasks/tracker-view/how-can-i-track-process-activities-on-tallyfy/)**: Every running process in Tallyfy has a built-in activity log that records task completions, deadline changes, comments, and assignment updates. Open any process and click the Settings gear icon, then the Activity tab to see who did what and when. ## View the activity log for a process Every running Tallyfy [process](/products/pro/tracking-and-tasks/processes/) has an activity log showing what's happened and who did it. It's useful for tracking progress or troubleshooting issues. The log records actions like: * Task completions or re-opens * Deadline changes * Comments added * Process archiving/unarchiving * Assignment and ownership updates ### How do I view the process activity log? 1. Open the running process (e.g., from the **Tracker** view). 2. Click the **Settings** button (gear icon) in the top right corner. 3. Click the **Activity** tab in the panel that opens. 4. The most recent events appear at the top. ![Process activity log showing recent events in Tallyfy](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-check-process-activity.png) :::note[Activity timestamp display] Tallyfy stores activity timestamps in ISO 8601 format. The interface converts them to your personal timezone setting, so you'll always see accurate local times. ::: :::note[Permissions] **Administrators**, the process creator, task assignees, and [members](/products/pro/documenting/members/) with read permission on the process can see its activity log. ::: - **[Create custom views](https://tallyfy.com/products/pro/tracking-and-tasks/tracker-view/how-to-create-custom-views-in-tallyfy/)**: Save filtered combinations in the Tracker as named presets so you don't need to re-apply filters every time. Instantly recall specific process views based on assignee, tag, and status. ## Create custom views in Tracker Save filtered views as **Presets** in the **[Tracker](/products/pro/tracking-and-tasks/tracker-view/)** to instantly access specific process subsets. For example, you'd create a preset showing processes assigned to your team, tagged "Urgent", and approaching their deadlines. You'll find your saved preset in the **Custom Views** dropdown in Tracker. Click it to re-apply that filter combination anytime. - **[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's Tracker lets you toggle between a visual Board view with process cards and a detailed Table view with sortable columns. The table view resets to the first blueprint when you leave the page, so use in-app links to return. ## Switch between board and table formats The **[Tracker](/products/pro/tracking-and-tasks/tracker-view/)** has two view formats you can switch between at any time: * **Board view** (default) - Shows processes as visual cards you can group and scan quickly * **Table view** - Lists processes as rows with sortable, filterable columns for detailed tracking :::note Table view is only available for organization members. Guest users can only see the Board view. ::: ### How do I switch between views? 1. Open the **Tracker** from the left sidebar. 2. Find the **View** dropdown near the top of the page. 3. Select **Board** or **Table**. ![Tracker view mode dropdown showing Board and Table options](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-change-tracker-view-mode.png) ### How can I customize the table view? Table view requires you to pick a template (blueprint) first. Once selected, you'll see processes listed as rows with columns like Name, Progress, Status, Due, Started By, Process Owner, Start Date, Last Updated, Assigned, Next Step, and more. You can show or hide columns to focus on what matters most. ![Table view with column customization options](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-customize-table-view.png) ## Table view navigation tips **Known behavior** - Table view resets to the first blueprint in your dropdown when you leave and come back. This happens because the selected blueprint isn't always preserved in the URL. **Common triggers**: - Using the browser back button instead of Tallyfy's sidebar navigation - Following external links back to the tracker - Page refreshes or session timeouts - Bookmarks that don't include the blueprint parameter **How to work around it**: 1. **Use in-app navigation** - Click the Tracker menu item instead of browser back 2. **Bookmark after selecting** - The URL includes your blueprint selection once chosen 3. **Expect reselection after refresh** - Just pick your blueprint again from the dropdown. Your data isn't affected - only the view selection resets. - **[Organize processes](https://tallyfy.com/products/pro/tracking-and-tasks/tracker-view/organize-processes/)**: Tallyfy lets you organize active processes using folders, favorites, filters, and archiving. Quickly find and manage running workflows in the way that suits your team best. ## Ways to organize processes You can manage your view of active [processes](/products/pro/tracking-and-tasks/processes/) in Tallyfy by adding them to folders, marking them as favorites, filtering your view, or archiving completed ones. Pick what's best for you below. ### 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 lets you group active processes into folders in the Tracker view by client or project and uses separate folder systems for templates versus running processes so you can filter and find work instantly. ## Organize active processes into folders You can group active [processes](/products/pro/tracking-and-tasks/processes/) into folders in the **[Tracker](/products/pro/tracking-and-tasks/tracker-view/)** view - by client, project, status, or whatever makes sense for your team. Here's how it works. :::note[Why are process folders separate from template folders?] Tallyfy keeps separate folder systems for [templates](/products/pro/documenting/templates/) and active processes. That's because you'll want to organize them differently: - 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"). An "Employee Onboarding" template might live in an "HR" template folder, while running onboarding processes go into folders like "Sales Onboardings" or "IT Onboardings". ::: ### 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 that folder's processes: ![Filter by folder in Tracker view](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-filter-by-folder-process.png) - **[Favorites and watching](https://tallyfy.com/products/pro/tracking-and-tasks/tracker-view/organize-processes/how-can-i-favorite-and-filter-processes-on-tallyfy/)**: Star processes, tasks, members, and templates to bookmark them for quick access. Starring also watches items, so you'll get notifications about specific events at your chosen frequency. ## Favorites - bookmarking and watching Click the star icon in the left sidebar to open Favorites. It lets you bookmark items (processes, tasks, members, templates) for quick access. Starring an item also "watches" it - you'll get notifications when specific events happen to that item. ### What does "watching" mean? When you watch an item by starring it, Tallyfy notifies you about specific events. The events that trigger notifications depend on the item type. ### What events trigger notifications? #### Templates (procedure and document) When you watch a template, you'll be notified about: - **Step creation** - New steps added to the template - **Step deletion** - Steps removed from the template - **Assignee changes** - Step assignees added or removed - **Form field creation** - New form fields added to steps - **Form field deletion** - Form fields removed from steps Document templates also trigger notifications when their content is updated. #### Tasks (including one-off tasks) When you watch a task, you'll be notified about: - **Task completion** - The task is marked complete - **Assignee changes** - Task assignees are added or changed - **Deadline changes** - The task deadline is modified - **Task reopening** - The task is reopened after completion Comments, file attachments, and form field value changes don't trigger watcher notifications. #### Processes When you watch a process, you'll be notified about: - **Task completion** - Any task within the process is completed - **Process completion** - The entire process finishes - **Archiving/restoring** - The process is archived or restored - **Owner changes** - The process owner is changed #### 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 assigned task ### How do I access Favorites? Click the star icon in the left sidebar. You'll see all your bookmarked items. ![Favorites section in the left sidebar](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. ![Star icon on a process in Tracker view](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. ![Star icon on a task](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. ![Star icon on a member profile](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. ![Star icon on a template](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-favorite-template.png) Click the star again to unfavorite and unwatch the item. ### How do I filter Favorites? Use the filter options at the top of the Favorites section to show only certain item types - for example, only favorited processes or only favorited tasks. ![Filter options in the Favorites section](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-filter-favorite.png) ### How can I set notification preferences? For each favorited item, you can control how and how often you're notified. * **Target options** - Choose *how* you want notifications: * **Email** - Receive notifications via email * **Webhook** - Send notifications to external systems via webhook URLs ![Notification target options for a favorited item](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-target-options-favorite.png) * **Notification frequency** - Choose *when* notifications arrive: * **Electric** - Immediate notification when an event happens * **Mindful** - Digest sent every 3 hours * **Chilled** - Daily digest sent once per day ![Notification frequency options for a favorited item](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-frequency-options-favorite.png) You can mix frequencies across items. Get instant alerts for critical items and daily digests for less urgent ones. The events that trigger notifications stay the same - only the delivery timing changes. ### How do I manage watched items? The Favorites section is your hub for managing watched items: * View all favorited/watched items * Change notification settings (frequency and target) per item * Filter the list by item type * Unfavorite items by clicking the star again - **[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/)**: Archive processes to remove them from your active Tracker view without deleting them. Unarchive later using a status filter. Light users can't archive directly, but auto-archive handles completed processes automatically. ## Archive and unarchive processes Archiving removes a [process](/products/pro/tracking-and-tasks/processes/) from your active Tracker view without deleting it. You can unarchive it later to bring it back. :::note[How can I pause or stop processes?] Tallyfy doesn't have a "pause" or "stop" feature. If a process was started incorrectly, isn't needed, or was just for testing - **archive** it. You can [permanently delete archived processes](/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**: ❌ Can't archive processes The archive button appears for Light users, but clicking it won't work - the server returns a permission error. **Workaround** - enable auto-archive so completed processes archive themselves: 1. Go to **Settings** > **Organization** > **Customization** 2. Turn on auto-archive for completed processes 3. Processes will automatically archive after a configured period once all tasks are done ::: ### How do I archive a process? ### How do I unarchive a process? ### Miscellaneous - **[About Tallyfy](https://tallyfy.com/products/pro/miscellaneous/about-tallyfy/)**: Tallyfy is a profitable, independent company operating since 2015 with full data portability, SOC 2 Type 2 compliance, and transparent pricing. No venture capital means direct accountability to users. ## Why you can trust Tallyfy ### Stable and profitable since 2015 Tallyfy has operated continuously since 2015 as a profitable, independent company. Over a decade 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 serving customers, not investors. ### Your data belongs to you 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/) gives you full programmatic access to extract, back up, or migrate your data. We also 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 design Tallyfy works with what you already have. Every feature in the 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. Without venture capital: - Customer needs drive every product decision - No pressure to sell or exit for investor returns - 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 - Encryption at rest and in transit ### Fair, transparent pricing Our [Fair Price Guarantee program](/products/pro/pricing/) means consistent pricing regardless of where you're located. 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]. ### Why independence matters Industry statistics on venture-backed companies tell a cautionary tale: - 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] - **[Email campaigns vs task reminders](https://tallyfy.com/products/pro/miscellaneous/can-tallyfy-send-email-campaigns/)**: Tallyfy isn't an email campaign tool. It uses built-in task reminders like daily digests and deadline notifications to keep contacts engaged with their work. Use dedicated email platforms for mass marketing, connected through middleware. ## Can Tallyfy send email campaigns? Tallyfy is a workflow management platform - not an email marketing tool. It doesn't send broadcast email campaigns like Mailchimp or HubSpot would. However, Tallyfy's built-in task reminders serve a similar purpose for your existing contacts. When someone has an assigned task, they receive: - **Daily digest emails** summarizing their pending tasks and upcoming deadlines - **Task-specific reminders** when deadlines approach or tasks are overdue - **Step completion notifications** when upstream tasks finish and new work is ready These reminders go out regularly, so you don't need to manually follow up. ### When to use Tallyfy vs email tools | Need | Use | |------|-----| | Broadcast marketing to thousands of contacts | Email campaign tool (Mailchimp, SendGrid, etc.) | | Reminding known contacts to complete specific tasks | Tallyfy task reminders | | Collecting information from clients or vendors | Tallyfy [public kick-off forms](/products/pro/launching/triggers/kick-off-forms/) | | Sending a one-time notification within a workflow | Tallyfy [email step type](/products/pro/tracking-and-tasks/tasks/) | | Nurturing leads with drip sequences | Email campaign tool | Tallyfy is built for warm, known connections - clients, partners, vendors, and team members who need to complete work. For cold outreach or mass marketing, use a dedicated email platform and connect it to Tallyfy via [middleware](/products/pro/integrations/middleware/) if you need the responses to trigger workflows. - **[Tallyfy on mobile devices](https://tallyfy.com/products/pro/miscellaneous/does-tallyfy-work-on-all-devices/)**: Tallyfy runs on any device with a modern browser as a responsive web app with no installation needed. It also offers a desktop app for macOS and Windows with native notifications and system tray integration. ## Device and platform compatibility Tallyfy works on any device with a modern web browser. It's a responsive web app - so there's nothing to install or configure per device. ### Screen size adaptation Tallyfy's interface automatically adjusts to fit desktops, tablets, and smartphones. You'll get the same features on every screen size without needing separate app downloads. ### Mobile and remote access You can manage workflows from anywhere - whether you're traveling or working remotely. All features work the same regardless of which device you're using. ![Tallyfy mobile dashboard view](https://screenshots.tallyfy.com/Tallyfy-mobile-dashboard.png) ### No separate mobile app needed Tallyfy doesn't have a separate mobile app in app stores because the responsive web app works great on phones already. You get instant access with no install delays, no storage overhead, and no app store dependencies. ### Desktop app for enhanced productivity If you want native desktop integration, Tallyfy offers a desktop app for macOS and Windows. It provides: - **Native notifications** that work even when your browser is closed - **System tray integration** for quick access - **Automatic login** *(macOS)* using your existing Chrome browser sessions. On Windows you sign in the normal way - **Auto-updates** so you always have the latest version [Learn how to install the Tallyfy desktop app](/products/pro/miscellaneous/how-can-i-install-the-tallyfy-desktop-app/) - **[Become a Tallyfy partner](https://tallyfy.com/products/pro/miscellaneous/how-can-i-become-a-tallyfy-partner/)**: Tallyfy's partner program lets consultants and agencies earn rewards and access client accounts at no extra cost. Partners use unbilled domain exclusions so their team doesn't add to client billing. ## Becoming a Tallyfy partner Tallyfy partners with consultants, agencies, and software companies who want to help their clients manage workflows and improve business processes using Tallyfy. ### What partnership types does Tallyfy offer? - **Solution Partners** - Consultants and agencies who implement Tallyfy for their clients - **Technology Partners** - Software companies who integrate their products with Tallyfy - **Referral Partners** - Organizations who refer qualified prospects to Tallyfy ### What benefits do partners receive? - Earn **rewards** for successfully referred clients - Option to **provide value-added services** to clients - Access a **partner dashboard** to track performance - **Unbilled Domain Access** - your team accesses client accounts without increasing their costs (details below) - Opportunities for **joint marketing** and collaboration - **Priority technical support** for partner issues and implementations - Access to **partner resources and training materials** - Offer **consulting services** using Tallyfy metrics to improve client processes and deliver measurable 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 solves this: 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 from `@yourconsultancy.com` is automatically marked as "Unbilled" 3. When Tallyfy calculates account usage, it counts only the client's employees - not "Unbilled" partner members **Practical example:** - ClientCorp adds `partner.com` to their exclusion list - ClientCorp has 15 employees (`@clientcorp.com`) and 5 consultants (`@partner.com`) using Tallyfy - ClientCorp's account counts only their 15 employees - consultants access the system at no extra cost This means partners can collaborate freely within client accounts without adding to the client's bill. :::note[Important for partners] The unbilled domain feature applies only to your client organizations - the ones you refer to Tallyfy. In your own Tallyfy organization, all active users (including those with your company domain) are billed normally per your subscription plan. The partner benefit is that your team can access client accounts without increasing the client's costs. ::: ### What commitments are required? Partners agree to these program requirements: - **Active Tallyfy account** - You must maintain an active account that serves as a demo environment for potential customers - **Agreement compliance** - You must follow the terms in the Tallyfy Referral Agreement, Trademark Usage Guidelines, Customer Terms of Service, and Privacy Policy - **Active promotion** - You're expected to actively promote Tallyfy through your website and marketing channels - **Prohibited activities** - Don't associate Tallyfy marketing materials with unlawful, harmful, defamatory, obscene, or offensive content. Sending spam to promote Tallyfy is strictly prohibited - **Trademark usage** - You must use Tallyfy trademarks, logos, and marketing materials only as specified in the Trademark Usage Guidelines ### Applying for partnership ### More information For questions about the partnership program, contact our team at [partner@tallyfy.com](mailto:partner@tallyfy.com). - **[Glossary](https://tallyfy.com/products/pro/miscellaneous/glossary/)**: A quick-reference glossary of Tallyfy platform terms. Covers templates, processes, automation rules, kick-off forms, guest access, API concepts, and more. ## Key terms for Tallyfy This glossary covers the main terms you'll encounter while using Tallyfy. ### A [**Administrator**](/products/pro/documenting/members/) Administrators have full access to everything in the organization - creating and editing templates, managing settings, and overseeing all members. [**Agentic workflow**](/products/pro/integrations/computer-ai-agents/rpa-vs-computer-use-agents/) Agentic workflows use AI agents that autonomously plan, execute, and adapt action sequences to hit high-level business goals. This differs from traditional linear, predefined workflow scripts. [**Analytics**](/products/pro/integrations/analytics/) Tallyfy Analytics provides business intelligence tools and reports that give you insights into process performance, task completion times, and workflow efficiency. [**API (Application Programming Interface)**](/products/pro/integrations/open-api/) Tallyfy's API lets external software interact programmatically with the platform through standardized endpoints. [**Approve/reject task**](/products/pro/tracking-and-tasks/tasks/what-types-of-tasks-can-i-create-with-tallyfy/) A task type where the assignee must either approve or reject a submitted item. These often act as decision gateways in a workflow. [**Assignee**](/products/pro/documenting/templates/edit-templates/understanding-assignment-types/) The person responsible for completing a specific task within a process. [**Automation rule**](/products/pro/documenting/templates/automations/) An "if-this-then-that" condition that makes processes adapt automatically based on triggers, data values, or workflow events. [**Auto-send email**](/products/pro/tracking-and-tasks/tasks/what-types-of-tasks-can-i-create-with-tallyfy/) A task type that automatically sends a predefined email when the workflow reaches a specific step - no manual review needed. ### B [**Blueprint**](/products/pro/integrations/open-api/) The API's name for what the Tallyfy UI calls a "template." You'll see this term when working with the API or building integrations. [**BPMN (Business Process Model and Notation)**](/products/pro/documenting/templates/how-to-convert-bpmn-patterns-into-tallyfy-templates/) A standardized graphical notation for representing business processes in diagrams. BPMN diagrams can be converted into Tallyfy templates. [**Board view**](/products/pro/tracking-and-tasks/tracker-view/how-to-switch-between-board-and-table-formats-in-tallyfy-tracker/) Displays processes as visual cards in Tallyfy's Tracker, giving you a Kanban-style view with drag-and-drop management. ### C **Capture** The API and internal code name for a [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/). When you read the Tallyfy API, you'll see `captures` where the app says "form fields". [**Checklist field**](/products/pro/tracking-and-tasks/tasks/how-to-create-and-use-subtasks/) Lets you create subtasks within a parent task, with configurable completion rules and progress tracking. [**Computer AI agent**](/products/pro/integrations/computer-ai-agents/) Software that can perceive digital environments, make autonomous decisions, and execute tasks - automating web and application interactions that previously needed a human. [**Compliance**](/products/pro/compliance/) Tallyfy's compliance features help organizations meet regulatory requirements through documentation, audit trails, and standardized process controls. [**Conditional logic**](/products/pro/documenting/templates/automations/) Rules that determine which path a workflow takes based on data conditions, user responses, or system states. These "if-this-then-that" rules make workflows dynamic. [**CSV export**](/products/pro/tracking-and-tasks/processes/how-can-i-export-tallyfy-processes-to-csv/) Exports process data to CSV format so you can analyze it in spreadsheets or other tools. **Custom field** An organization-defined label and value attached to a Tallyfy record as metadata - for example, a cost center on a process or a region on a guest. Custom fields tag the record itself, so they're different from [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/), which collect data people fill in inside a task or kick-off form. See [custom fields](/products/pro/integrations/open-api/custom-fields/) for the API. [**Custom view**](/products/pro/tracking-and-tasks/tracker-view/how-to-create-custom-views-in-tallyfy/) A saved Tracker configuration that filters and displays processes based on criteria you define. ### D [**Dashboard**](/products/pro/) Your central hub showing recent processes, assigned tasks, announcements, and key metrics. [**Deadline**](/products/pro/documenting/templates/edit-templates/) The date and time a task must be **completed** by. This is different from a start time, which shows when work should begin. [**Document template**](/products/pro/documenting/documents/) A reusable document structure with fixed content 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 task type that prepares an email for human review and approval before it's sent. [**Expiring step**](/products/pro/tracking-and-tasks/tasks/what-types-of-tasks-can-i-create-with-tallyfy/) A time-sensitive task that auto-completes after a set period, keeping the workflow moving forward. ### F [**Field**](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) A data entry element where users input information - text, numbers, dates, file uploads, and more. [**Folder**](/products/pro/documenting/templates/organize-templates-into-folders/) A way to group templates or tasks into logical categories for easier navigation. [**Form**](/products/pro/tutorials/how-to/build-effective-forms/) A structured set of fields designed to collect specific information from users or external collaborators. ### G [**Guest**](/products/pro/documenting/guests/) Someone outside your organization who can participate in specific processes without needing a Tallyfy license or account. ### I [**Integration**](/products/pro/integrations/) A connection between Tallyfy and an external system that enables automated data exchange and action triggering across platforms. [**Interactive email actions**](/products/pro/integrations/interactive-email-actions/) A feature that lets email recipients approve, reject, or complete tasks directly from email notifications - no Tallyfy login required. [**Intelligent Process Automation (IPA)**](/products/pro/integrations/computer-ai-agents/rpa-vs-computer-use-agents/) An automation approach that combines human tasks, RPA bots, and Computer AI Agents within unified workflows. ### J [**Job title assignment**](/products/pro/documenting/templates/edit-templates/understanding-assignment-types/) Assigning tasks to a role instead of a specific person, so whoever holds that role completes the task. ### K [**Kick-off form**](/products/pro/launching/triggers/kick-off-forms/) The initial form that collects information when you launch a process. ### L [**Launch**](/products/pro/launching/) Starting a new process from a template. [**Light user**](/products/pro/documenting/members/) A user role with limited capabilities - they can complete tasks but can't create or edit templates. ### M [**Magic link**](/products/pro/launching/triggers/magic-links/) A special URL that lets anyone launch a process - even people without a Tallyfy account. [**Member**](/products/pro/documenting/members/) A registered user within your Tallyfy organization with an assigned role. [**Middleware**](/products/pro/integrations/middleware/) A custom code layer that handles integrations between Tallyfy and other systems. ### O [**OAuth**](/products/pro/integrations/open-api/oauth-authorization-flow/) An authorization protocol that lets third-party apps access Tallyfy's API on behalf of users without sharing passwords. [**Organization**](/products/pro/settings/org-settings/) The top-level account in Tallyfy containing 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 setup. ### 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 functionality. **Prerun** The API and internal code name for the data captured by a [kick-off form](/products/pro/launching/triggers/kick-off-forms/). When you read the Tallyfy API, you'll see `preruns` where the app says "kick-off form". [**Process**](/products/pro/tracking-and-tasks/processes/) A running instance of a template - it tracks the execution of a specific workflow. Called a "run" in the API. [**Process lifecycle**](/products/pro/tracking-and-tasks/processes/process-lifecycle-management/) The phases a process goes through: creation, launch, execution, monitoring, and completion. [**Process notes**](/products/pro/tracking-and-tasks/processes/edit-processes/how-to-add-process-notes/) Extra context you can add to a process for better communication and documentation. [**Procedure template**](/products/pro/documenting/templates/) A reusable workflow definition that outlines 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 formatting tool that lets you style text, add links, embed images, and more in task descriptions and fields. [**RPA (Robotic Process Automation)**](/products/pro/integrations/computer-ai-agents/rpa-vs-computer-use-agents/) Software "bots" that mimic repetitive, rule-based human actions on digital systems using pre-programmed scripts. [**Role**](/products/pro/documenting/members/) Defines what a user can do in Tallyfy - Administrator, Standard, or Light. **Run** The API and internal code name for a [process](/products/pro/tracking-and-tasks/processes/). When you read the Tallyfy API, you'll see `runs` where the app says "processes". ### S [**Single Sign-On (SSO)**](/products/pro/integrations/authentication/) Lets users access Tallyfy using their existing corporate credentials. [**Snippet**](/products/pro/documenting/templates/snippets/) Reusable content blocks you can insert into templates. Edit the snippet once, and it updates everywhere it's used. [**Standard user**](/products/pro/documenting/members/) A user role that can create and edit templates but can't 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, start times provide scheduling guidance but aren't enforced. [**Step**](/products/pro/documenting/templates/) A component in a template that becomes a task when the 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 for granular tracking. ### T [**Table view**](/products/pro/tracking-and-tasks/tracker-view/how-to-switch-between-board-and-table-formats-in-tallyfy-tracker/) Shows processes in a spreadsheet-like layout with rows and columns in the Tracker view. **Tags** Keywords or labels added to templates and processes for categorization and filtering. [**Task**](/products/pro/tracking-and-tasks/tasks/) A single unit of work within a process, 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 every process. [**Template**](/products/pro/documenting/templates/) A reusable blueprint that defines a standardized process or document. Called a "blueprint" or "checklist" in the API. [**Template import**](/products/pro/documenting/templates/import-feature/) Lets you import templates from CSV files or other sources to quickly build 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 - all automated actions are visible, accountable, and continuously improvable. [**Tracker view**](/products/pro/tracking-and-tasks/tracker-view/) 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/) Finds content across all areas of Tallyfy. ### V [**Variable**](/products/pro/documenting/templates/variables/) A placeholder in templates that gets filled with specific information when a process runs. **Version control** Tallyfy automatically tracks changes to templates, so you can view previous versions. ### W [**Webhook**](/products/pro/integrations/webhooks/) A way for Tallyfy to send real-time notifications to other systems when specific events occur. [**Workflow**](/products/pro/documenting/templates/) A sequence of tasks that make up a business process, typically set up as a procedure template in Tallyfy. Some older API documentation and Swagger references use "workflow" as another name for a process (`run`). - **[Generate a HAR file for troubleshooting](https://tallyfy.com/products/pro/miscellaneous/how-can-i-generate-a-har-file-for-troubleshooting/)**: A HAR file captures all browser network activity, including requests and responses. Generate one through Developer Tools in Chrome, Firefox, Edge, or Safari to give support teams the diagnostic data they need for troubleshooting. ## What's a HAR file and why does support need one? A HAR (HTTP Archive) file[^1] records everything your browser does on the network: every request, response, and load time. When you're hitting a speed issue, caching problem, or a bug that's hard to reproduce, a HAR file gives our support team the exact data they need to diagnose what's going wrong. ### How to generate a HAR file #### Chrome #### Firefox #### Microsoft Edge #### Safari > Internet Explorer doesn't support HAR file export. If you're still on IE, please switch to Chrome, Firefox, or Edge to generate the HAR file. ### Sending the HAR file to support Attach the HAR file directly to your support ticket or email. It contains the network-level detail our team needs to pinpoint and fix your issue. [^1]: A JSON-formatted archive that logs all browser-server communication during a browsing session - **[Install the Tallyfy desktop app](https://tallyfy.com/products/pro/miscellaneous/how-can-i-install-the-tallyfy-desktop-app/)**: Tallyfy's desktop app for macOS and Windows wraps the web app with native notifications, system tray access, and a dedicated window outside your browser. On macOS it can also sign you in automatically using your existing Chrome login. ## How to install the Tallyfy desktop app The Tallyfy desktop app wraps the same web app you already use, so all features work the same, but it adds desktop benefits like native notifications and system tray access. ### Why use the desktop app? - **Native notifications** - Get task reminders even when your browser is closed - **System tray** - Quick access from your menubar or taskbar - **Automatic login** *(macOS)* - The app can import your existing Google or Microsoft login from Chrome, so you may already be logged in. On Windows you sign in normally, the usual way - **Auto-updates** - New versions install automatically - **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 and drag the Tallyfy icon to your Applications folder 3. On first launch, right-click the app and select **Open** to bypass Gatekeeper (the app isn't notarized yet) 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 appears in your Start menu #### Linux Tallyfy publishes desktop builds for macOS and Windows only, which is why there's no Linux row in the download table above. The app can be built for Linux, so contact support if you need one. ### System requirements | Platform | Minimum version | |----------|-----------------| | macOS | 12.0 (Monterey) or later | | Windows | Windows 10 or later | | Linux | No published build. Available on request, see the Linux section above | ### Signing in On macOS, the app tries to import your existing login from Chrome on first launch. If you're already signed into Google or Microsoft in Chrome, you may be logged into Tallyfy right away. On Windows the app doesn't do this, so just sign in below. To sign in yourself, or 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 yet have an extended validation certificate. **Not logged in automatically** The Chrome cookie import is a macOS feature. It isn't part of the Windows app, so on Windows this is expected: click any sign-in option and complete the flow as described above. On macOS, the import needs access to Chrome's Safe Storage, so you'll be prompted to allow Keychain access. Click **Allow** to enable automatic login. **App won't start** Make sure you have the correct version for your system architecture (Intel vs Apple Silicon on Mac, 64-bit vs 32-bit on Windows). - **[See product updates](https://tallyfy.com/products/pro/miscellaneous/how-can-i-stay-updated-with-tallyfys-latest-features/)**: Check Tallyfy's latest product updates by clicking your name and selecting Latest Updates in the app. You can also visit tallyfy.com/changelog for release notes and feature announcements. ## How to see what's new in Tallyfy There are two ways to check what's changed: ### Inside the app Click your name in the top-right corner, then select **Latest Updates** from the dropdown. You'll see recent improvements and new features. ### On the changelog page Visit [tallyfy.com/changelog](https://tallyfy.com/changelog/) for detailed release notes and feature announcements. ![Latest Updates option in the Tallyfy profile dropdown menu](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-check-updates.png) - **[Translate content](https://tallyfy.com/products/pro/miscellaneous/how-can-i-translate-content-in-tallyfy/)**: Tallyfy supports interface language switching and Azure AI-powered content translation for multilingual teams. Administrators can connect Microsoft Azure Cognitive Services for real-time translation of user-generated content across 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 admin 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 and supports 100+ languages. #### Requirements * Active Microsoft Azure account with translation services enabled * API Key and Region/Location credentials for the Azure Translator service * Administrator access in 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 it's 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 industry jargon might not translate accurately. **RTL (Right-to-Left) support** - Tallyfy doesn't currently support RTL languages like Arabic or Hebrew for interface display. You can translate content to these languages, but the layout stays left-to-right. Full RTL support isn't available yet but is being considered. ::: - **[File storage and security](https://tallyfy.com/products/pro/miscellaneous/how-does-file-storage-work-in-tallyfy/)**: Tallyfy stores uploaded files in Amazon S3 with plan-based limits from 5GB to 25GB per member. You can also link to files in external cloud storage like Dropbox or SharePoint without using your quota. ## 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 You can upload files to steps, [tasks](/products/pro/tracking-and-tasks/tasks/), forms, and comments. Tallyfy stores all uploaded files securely in Amazon S3 buckets[^1] with full data protection. #### Storage limits by plan - All uploaded PDFs, documents, images, screenshots, audio, and video files count towards your storage limit - Default storage location is US West (AWS Oregon) - Storage limits vary by plan: - **Docs plan** - 5GB total organizational storage - **Basic plan** - 5GB per [member](/products/pro/documenting/members/) - **Pro plan** - 25GB per member - **Enterprise plan** - Custom limits based on your needs #### Storage considerations - File links from external apps like Box, Dropbox, Google Drive, or OneDrive do **not** count towards your Tallyfy storage limit - When you're approaching storage limits, Tallyfy notifies you with these options: - Delete outdated or unnecessary files - Upgrade your plan for more storage - Future "bring your own storage" options (contact support for updates) ### Security and compliance For full IT, [compliance](/products/pro/compliance/), and [security](/products/pro/compliance/) details about file storage, visit the [compliance and security page](https://tallyfy.com/legal/compliance-security/). Data export capabilities vary by plan - contact support for details. ### Recommended approach Tallyfy focuses on workflow management, not file storage. Use your existing cloud storage (Dropbox, Box, Google Drive, SharePoint) for file management and link those files in Tallyfy workflows. Learn how 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 part of the process flow and need to be directly accessible within tasks - **Simple file needs** - When you don't need advanced features like version control or redlining - **Audit trail tracking** - Files that need to be tracked as part of the process record - **Smaller file sizes** - Files under the 150MB upload limit #### When to use external storage (SharePoint, etc.) - **Document management needs** - When you need redlining, version control, or collaborative editing - **Regulatory compliance** - Organizations with specific storage requirements (HIPAA, life sciences, etc.) - **Large file handling** - Videos or large files exceeding the 150MB limit - **Existing governance** - When you've established DMS policies or approved file systems #### A hybrid approach works best Many organizations combine both approaches: - **Draft documents** - Use external storage links for collaborative work - **Final documents** - Upload final PDFs to Tallyfy for process completion and archival - **Process-specific files** - Tallyfy for workflow-critical documents, external storage for supporting materials - **Sensitive files** - Link to internal file servers for sensitive documents while maintaining workflow tracking ### Technical specs #### Tallyfy storage - **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** - Amazon S3 storage with full data protection - **Access** - 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 in task descriptions. Tallyfy won't access files uploaded through these external requests - **Direct file linking** - Upload files to your preferred storage platform, then paste the file links into Tallyfy [fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) or task descriptions - **No storage impact** - 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** - Upload to Tallyfy for process completion and audit trail - **Client communications** - External file server links for sensitive documents #### Healthcare and 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/). [^1]: Amazon's highly durable cloud object storage service, widely used for enterprise file hosting - **[Login and session errors](https://tallyfy.com/products/pro/miscellaneous/how-to-connect-tallyfy-to-other-apps-using-private-browsing/)**: Private browsing mode fixes Tallyfy connection issues with external apps by starting a clean session without stored cookies, cached data, or saved credentials that cause login conflicts and authorization problems. ## Using private browsing for app connections When connecting Tallyfy to external tools like middleware, Slack, or Google Drive, you might hit login or authorization problems. These usually come from conflicting login info, cached data, or stored cookies in your regular browser session. Your browser's **private browsing mode** (also called Incognito, InPrivate, or Private Window) fixes these issues by giving you a clean session - no stored cookies, cached data, or saved credentials. ### When to use private browsing Open a private browsing window when you experience: - Login errors during authorization - Repeated connection failures or timeouts - Troubleshooting requests from Tallyfy support - Multiple account conflicts (e.g., different Google accounts) during connection setup ### Opening private browsing #### Chrome #### Firefox #### Microsoft Edge #### Safari (Mac) ### Additional troubleshooting steps If private browsing doesn't fix the issue, try these alternatives: ### Contacting support If these steps don't work, [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 you see. - **[Find your Tallyfy IDs](https://tallyfy.com/products/pro/miscellaneous/how-to-find-your-tallyfy-ids/)**: Every element in Tallyfy has a unique ID. Find Organization, Template, and Process IDs through Settings or your browser's address bar for support requests and integrations. ## Finding your Tallyfy IDs Every element in Tallyfy has a unique ID. You'll need these IDs when contacting [support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/), setting up [integrations](/products/pro/integrations/), or importing templates. ### Organization ID * Go to **Settings** > **Organization**. * You'll find your Organization ID in this section. ![Organization ID shown in Tallyfy settings](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-show-org-id.png) ### Template ID * Open the [template](/products/pro/documenting/templates/) in **Edit** mode. * Click the **Settings** (or **Config**) button in the top toolbar. * Go to the **Export** tab (sometimes labeled **Tools**). * You'll see the Template ID here, along with the Organization ID. ### Process ID * Open a running [process](/products/pro/tracking-and-tasks/processes/). * Look at the URL in your browser's address bar. * The URL follows this format: `https://go.tallyfy.com/[ORG_ID]/processes/[PROCESS_ID]`. * The part after `/processes/` is 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 lets you instantly find any template, running process, task, or snippet across your workspace. It searches through names, descriptions, tags, comments, and notes, with results that include folder paths and shareable links. ## Using Tallyfy's universal search Tallyfy's universal search helps you find anything across your workspace - [templates](/products/pro/documenting/templates/), running [processes](/products/pro/tracking-and-tasks/processes/), [tasks](/products/pro/tracking-and-tasks/tasks/), and [snippets](/products/pro/documenting/templates/snippets/). ### Performing a search Type what you're looking for into the search bar at the top of your interface. ### What can universal search find? Here's what universal search indexes across your Tallyfy organization: #### Templates * Tags and categories * Names and titles * Descriptions * Step names * Step descriptions #### Running processes and tasks * Process tags * Process names * Notes added to processes * Task names * Task descriptions * Comments on tasks #### One-off tasks * Task names and titles * Comments on standalone tasks #### Snippets * Snippet titles * Snippet content ### Search results display Results show all matching items with contextual information. For templates in folders, you'll also see the folder path so you can find the right template. ![Universal search results showing matching items with folder paths](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-search-bar-results.png) ### Sharing search results To share a direct link to any search result, click the **share icon** next to it. This copies a link to your clipboard that you can send to team members. ![Share icon next to a search result for copying a direct link](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-copy-search-result-link.png) - **[Differentiation](https://tallyfy.com/products/pro/miscellaneous/tallyfy-differentiation-guide/)**: Tallyfy gives people and AI one process to follow, with no flowcharts, no BPMN, real-time tracking, and AI that works inside your workflow while a human approves. Plus free 1:1 support for life, transparent all-inclusive pricing, and full data portability with no lock-in. ## What makes Tallyfy different Most workflow tools make you draw your process as a flowchart, then watch it gather dust. Tallyfy works the other way around. You write your process in plain steps once, then people and AI actually run it, with every task tracked in real time. Here's what sets Tallyfy apart, both as a product and as a company. ## A different kind of product ### Give people and AI one process to follow Document any process once. Assign each step to a person or an AI agent. Track every task in real time, so you can see exactly where things stand and skip the status meeting. One shared process keeps people and AI working the same way, every time. ### No flowcharts, no BPMN You don't draw your process in Tallyfy. You write it as simple steps anyone can read, with if-this-then-that rules for the decisions. No BPMN notation (the technical process-diagram standard), no diagramming tool, no consultant to translate it for you. If you can write a checklist, you can build a process. Here's [why we think flowcharts are the wrong tool](/products/pro/tracking-and-tasks/can-i-build-a-flowchart-in-tallyfy/) for running work. ### Minutes to set up, not months Legacy business process management (BPM) platforms take months of consulting to stand up. Tallyfy takes minutes, and your own team does it. Anyone in the business can create, run, and improve a process without waiting on IT. When something changes, you change it yourself in seconds. ### Real-time tracking, fewer status meetings Every running process shows live status: which step, who owns it, what's overdue. Nobody has to ask "where are we on this?" because the answer is already on the screen. Automatic reminders chase the next person, so work doesn't stall while someone forgets. ### Process first, AI second, accountability always AI is most useful when it works inside a process you control, not on its own. In Tallyfy, AI helps one step at a time, and a human reviews and approves at the points that matter. You get the speed of AI without losing the audit trail or handing over the keys. Process first. AI second. Accountability always. Tallyfy was also the first workflow platform with a built-in [MCP server](/products/pro/integrations/mcp-server/) (Model Context Protocol, the open standard AI assistants use to connect to tools). You can connect ChatGPT, Claude, Gemini, or Copilot to your processes from day one. ### One platform replaces your point tools Tallyfy replaces a stack of single-purpose tools because the process ties them together. Your kick-off form is the trigger that launches the workflow. A file-upload step collects documents and chases whoever is late. An approval step records the sign-off. Guests get a free view of just their tasks, so clients stay in the loop. Instead of paying for forms, document collection, approvals, and a client portal separately and wiring them together, you run it all in one place. ## A different kind of company ### Free 1:1 support for life Unlimited expert help at no extra cost, forever. No support tiers, no premium fees, just real people who help you succeed. Most vendors charge thousands for this or hide behind ticket queues. Check our [customer reviews](https://www.capterra.com/p/143084/Tallyfy/)[1]. ### Transparent pricing Our [pricing](/products/pro/pricing/) is on the website. Calculate your exact cost in seconds. No "contact sales" wall, no qualification calls, no surprise fees. Everything's included: SSO (single sign-on), unlimited guests, full API access. Many competitors charge $500-5000 extra just for SSO. ### Built to last We're profitable and self-funded. No investor pressure, no exit clock. Your processes and data sit with a company built to be here for decades, not until the next funding round runs out. Learn more [about our philosophy](/products/pro/miscellaneous/about-tallyfy/). ### Your data, your way Anything you can do in Tallyfy, you can do through our [API](/products/pro/integrations/open-api/). Export your data anytime. Connect your own [analytics tools](/products/pro/integrations/analytics/). There's no lock-in, by design. ### Security beyond the checkbox We're [SOC 2 Type II certified](/products/pro/compliance/), with HSTS for transport security, BIMI for email authentication, and GDPR and HIPAA-ready controls. Most vendors stop at the basics. We go further because security isn't a box to tick. ## How Tallyfy compares **vs. legacy BPM platforms** - Minutes to set up instead of months. No BPMN, no consultants, a fraction of the price. Your team runs it, not IT. **vs. project and task tools** - Built for repeatable processes, not one-off projects. Work flows from step to step automatically, instead of someone dragging cards across a board. **vs. automation middleware** - Tools like Zapier move data between apps. Tallyfy runs the work between people and AI, and tracks who did what. With AI and the MCP server, you need fewer brittle connectors. **vs. docs and collaboration tools** - A wiki or shared doc describes the work. Tallyfy makes the work happen, with tracking, reminders, and a record of every run. **vs. single-purpose point tools** - Forms, document collection, approvals, and guest access are built in and tied together by the process. One tool instead of five. For named, side-by-side comparisons, see our [alternatives guides](https://tallyfy.com/alternatives/). ## What this means for you **Lower cost** - One predictable price, with everything included. **Faster start** - Live in hours with real support, not a months-long rollout. **Less risk** - Longevity and full data portability mean no lock-in. **Ready for AI** - AI-native from the start, so you won't have to re-platform later. - **[Tallyfy vs. Projects](https://tallyfy.com/products/pro/miscellaneous/understanding-tallyfy-vs-project-management/)**: Tallyfy handles repeating business work like onboarding and invoice processing. Launch proven templates in clicks instead of recreating project plans, while project management tools work best for truly unique, one-time projects. ## Tallyfy vs. project management software Tallyfy handles predictable, repeatable workflows. 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. 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 how successful companies handle 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, one-time work - building a bridge, launching a campaign, developing software. Each project differs in tasks, timeline, and outcome. But 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 improve what you recreate from scratch ### The workflow management solution 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 ### 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 a complete workflow ### Task assignment **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 go to Senior Reviewer - Automatic workload balancing ### Improvement approach **Project management**: Lessons learned after project ends - Post-mortems gather dust - Next project makes same mistakes **Tallyfy workflows**: Continuous optimization - Update template and 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 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. If you've ever: - Onboarded a new customer or employee - Processed an invoice or payment - Handled a customer complaint - Prepared monthly reports - Managed inventory restocking ...then you use processes. The most successful companies don't just have processes - they document them, run them consistently, and improve them over time. **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 through email, memory, and sticky notes. Tallyfy 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 ::: ## 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) A construction company, for example, might use project management for building unique structures and Tallyfy for permit applications, safety inspections, and equipment maintenance. ## Breaking the project management habit ### "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?" and start thinking "How should this process work every time?" This shift from project to process thinking changes operations: - From reactive to preventive - From chaotic to calm - From variable to reliable - From stressful to systematic ## Getting started with workflow thinking 1. **Identify your repeating patterns** - What do you do weekly or monthly? - Which "projects" look suspiciously similar? - Where do mistakes repeat? 2. **Document the ideal process** (skip huge documents and crazy flowcharts) - Not how it sometimes works - How it should work every time - Include decision points and rules 3. **Build once, run forever** - Create a template in Tallyfy - Test and refine - Launch consistently 4. **Measure and improve** - Track completion times - Identify bottlenecks - Update the 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 supports keyboard shortcuts like Ctrl+Alt+T for creating tasks and Ctrl+Alt+P for launching processes. Use Tab and Spacebar to speed up form field completion without a mouse. ## Keyboard shortcuts in Tallyfy Keyboard shortcuts let you move through Tallyfy and finish work faster without reaching for the mouse. ### General shortcuts These shortcuts work on most Tallyfy pages. They won't work inside the template editor or when you're viewing running process details. - **Create a one-off task** - Press `Ctrl + Option + T` (Mac) or `Ctrl + Alt + T` (Windows) to create a standalone task. - **Launch a process** - Press `Ctrl + Option + P` (Mac) or `Ctrl + Alt + P` (Windows) to open the Templates section and launch a process. :::note[Key equivalents] The `Option` key on Mac is the same as `Alt` on Windows. ::: ### Shortcuts for completing forms When you're 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 speed up data entry: - **Tab key** - Move between form fields and cycle through options in dropdowns or radio button groups. - **Spacebar** - Select or toggle options, including dropdown items, radio buttons, checkboxes, and file upload buttons. - **[Adoption](https://tallyfy.com/products/pro/miscellaneous/support/)**: Drive team adoption of Tallyfy with five proven strategies, from involving users early to selecting high-impact processes. Built-in tools like auto-launch templates and universal snippets guide new members in real time. ## Getting support and helping your team adopt Tallyfy Here's how to get help from Tallyfy and drive successful adoption across your organization. ### Five essential strategies for workflow adoption Getting your team to adopt Tallyfy takes planning. These proven 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 help design workflows, they feel ownership - and that naturally drives adoption. It turns 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 Don't start 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 complete tasks, comment on processes, and reference Tallyfy in meetings, it shows this isn't just another tool that'll be abandoned. #### 4. Enable authentic peer sharing Encourage team members to share real experiences about how Tallyfy helps them. 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 - plan 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 You can automatically launch an onboarding template for new hires when they join. This 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. Set up "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 #### Measuring workflow adoption success Track these 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 voluntarily 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 come 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 on any device without friction * **AI assistance**: Generate process templates in seconds * **Legendary support**: Real humans help with adoption challenges * **No complex setup**: Start getting value from day one - **[Terms & legals](https://tallyfy.com/products/pro/miscellaneous/terms-legals/)**: Tallyfy provides enterprise security and legal compliance with SOC 2 Type 2 attestation, GDPR support, full data encryption, free SSO, and custom data processing agreements for regional privacy laws. ## Compliance and legal standards Tallyfy is built for the [security](/products/pro/compliance/), legal, privacy, and [compliance](/products/pro/compliance/) standards that larger companies and regulators expect. Here's what's in place to protect your data: * **SOC 2 Type 2 Attestation** - an independent auditor has checked that our security controls work and keep your data protected. * **HSTS Compliance** - HTTP Strict Transport Security. Browsers are pre-loaded to reach tallyfy.com only over an encrypted connection, which blocks man-in-the-middle attacks. * **BIMI Compliance** - Brand Indicators for Message Identification. It shows our verified logo on emails, which boosts brand recognition and helps prevent phishing. * **Custom Data Processing Agreements** - available for the EU, UK, or specific US states (like CCPA) to meet regional privacy laws. * **GDPR Compliance** - met through Data Privacy Framework (DPF) attestation for full European data protection. * **Enterprise Contract Flexibility** - custom contracts for specialized enterprise needs. * **Free Single Sign-On** - SSO[^1] is included free for every customer. Security shouldn't cost extra. * **Full Data Encryption** - all your data is encrypted both in transit and at rest, using industry-standard protocols. * **Logical Data Separation** - multi-tenant cloud hosting keeps each customer's data logically separate, hosted in the us-west-2 region on Amazon Web Services. * **AWS GovCloud Hosting** - available for customers who need higher security standards. It requires an enterprise contract. [Schedule a consultation](https://tallyfy.com/booking/) for details. * **Multi-layer API Security** - every [API](/products/pro/integrations/open-api/) request passes through Cloudflare Workers and Web Application Firewall protection. * **Sanctions Compliance** - access is blocked from countries under US trade sanctions. * **Anonymous Network Blocking** - requests from Tor browsers are blocked automatically. * **Edge Rate Limiting** - traffic is rate-limited at the network edge to handle spikes and prevent abuse. * **Enterprise Insurance Options** - custom insurance coverage for enterprises with specific liability needs. ### Achieving compliance with Tallyfy Tallyfy's [compliance automation software](https://tallyfy.com/solutions/compliance-automation-software/) helps organizations meet regulatory requirements through standardized processes, automated compliance tracking, and audit trails. [^1]: SSO (single sign-on) lets your team sign in to Tallyfy with the company login they already use, so there's no separate password. - **[Troubleshooting](https://tallyfy.com/products/pro/miscellaneous/troubleshooting/)**: Fix common Tallyfy issues like loading errors, authentication loops, rate limits, and password resets. Includes cache clearing steps, browser data wipe scripts, and Microsoft login approval guidance. ## Troubleshooting common Tallyfy issues When Tallyfy isn't loading properly, shows errors, or features aren't responding, these steps can resolve most issues before you need to contact support: 1. **Clear your browser's cache completely**: Outdated cached data often causes display and functionality problems. Choose your browser for 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 a different browser**: This helps determine if the issue is browser-specific or affects all browsers. 3. **Check your internet connection**: Make sure you've got a stable connection without intermittent drops. 4. **Disable browser extensions temporarily**: Ad blockers, privacy tools, and security extensions can interfere with Tallyfy. Disable them one by one to find the culprit. 5. **Update your browser**: Make sure you're running the latest version for best compatibility. ### Forcing your browser to load the latest version Browsers sometimes cache outdated versions of Tallyfy, causing functionality issues. A "hard refresh" forces your browser to bypass cached files and download fresh code from Tallyfy's servers. To do a hard refresh, right-click your browser's reload button and choose "Empty Cache and Hard Reload" (or a similar option). If that 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 stuck in an authentication loop where the system keeps asking for credentials, can't sign in, or gets caught in a redirect cycle - force a complete logout to clear all session data. #### Solution for authentication loop issues :::tip[When to use this solution] Use the logout URL when you experience: - Being asked for credentials repeatedly in a loop - Unable to get 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" during authentication ::: :::note[Why this happens] Authentication loops typically occur when: - Browser sessions become corrupted or conflicted - Multiple login attempts create overlapping sessions - Organization switching leaves leftover 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 fix persistent login or signout issues, you can use this script to wipe all Tallyfy-related data from your browser. It removes cookies, localStorage, sessionStorage, IndexedDB, cache storage, and service workers. :::caution[Important limitations] This script can't wipe data across all Tallyfy origins (e.g., `go.tallyfy.com`, `account.tallyfy.com`) in a single run because browsers enforce origin-based security. You'll need to run it on each Tallyfy domain you use. Also, HttpOnly cookies (server-only) can't 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 it per origin:** Browser security (same-origin policy) prevents JavaScript on one domain from accessing another domain's storage. Each Tallyfy subdomain keeps separate storage that can only be cleared when you're 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 script when: - The standard logout URL doesn't fix authentication loops - Clearing cache through browser settings hasn't worked - You're hitting persistent session conflicts across multiple Tallyfy origins - You need to completely reset your Tallyfy browser state - You're switching between organizations with conflicting sessions ::: ### Why am I seeing rate limit errors in Tallyfy? Tallyfy uses rate limiting to prevent abuse and keep the platform stable. If you exceed these limits, you'll see 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 hit a rate limit, wait the specified time before trying again. If your legitimate use case needs 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) find that resetting their password redirects them to create a new account instead. This happens when the system doesn't properly recognize their existing account status. #### Solution for password reset redirection issues :::note[Why this happens] This 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 starting the password reset. ::: ### Redirected to create an organization after login Sometimes after 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: :::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), try these steps: **Common causes**: - Browser cookies/cache preventing proper authentication - 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 make sure you've got the right 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 happens 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 admin 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 right away. 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 don't appear, try these fixes: * **Chrome QUIC protocol adjustment**: Go to `chrome://flags`, search for `QUIC`, set it to `Disabled`, and restart Chrome. * **Browser extension isolation**: Disable extensions one at a time to find which one is interfering with image loading. * **Security software configuration**: Temporarily disable your firewall or antivirus to test if it's blocking image requests, then add exceptions for Tallyfy if needed. ### Browser-specific troubleshooting guides These guides help resolve issues in specific browsers: ### Support - **[Contact support](https://tallyfy.com/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/)**: Tallyfy provides support through an in-app help bubble, email at support@tallyfy.com, and free 25-minute screen-sharing calls. Professional services cover process mapping and custom template development. ## Contacting Tallyfy support Here's how to reach our support team and get help with Tallyfy. ### Support options * **In-app help bubble** - Click the **Get Help** bubble (green, bottom right corner). Search help articles or send messages with screenshot attachments to the support team. * **Email support** - Send questions directly to `support@tallyfy.com`. * **Live screen-sharing calls** - Schedule free 25-minute screen-sharing sessions with Tallyfy experts through our [booking page](https://tallyfy.com/booking/). :::tip[Live support calls] You'll 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 projects that need deeper consultation or hands-on expertise, there's also Professional Services. Our support team will let you know when your needs fit these services: * **Dedicated account manager** - An expert assigned to your account for ongoing support. * **Process mapping consultation** - Help mapping complex business processes before building them in Tallyfy. * **Workflow optimization analysis** - Evaluation and improvement recommendations for your workflows. * **Custom template development** - Creation of templates tailored to your specific business requirements. * **Pilot program implementation & ROI analysis** - Help setting up pilot programs, measuring success metrics, and calculating return on investment. * **Advanced integration design** - Help designing, configuring, and testing connections to external systems. * **Change management & team training** - 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 includes a built-in user guide that's accessible right inside the app. Click the ? icon in the sidebar to search articles, or select Help and FAQs from your profile menu. ## Finding the in-app user guide Tallyfy has a built-in user guide, so you don't need to leave the app to find answers and step-by-step guides. There are two ways to access it: - **[Provide context to support](https://tallyfy.com/products/pro/miscellaneous/support/how-to-provide-necessary-info-to-tallyfy-support/)**: When you contact Tallyfy support, provide the full browser URL for the specific item and your Organization ID from Settings > Organization. This helps the team quickly find your account and resolve your issue. ## What info does Tallyfy support need? When you contact support, they'll usually ask for two things to find and fix your issue fast: 1. **The full URL from your browser** - 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 [guest task link](/products/pro/documenting/guests/how-to-find-a-guest-task-link-in-tallyfy/), 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 find your account. You'll find it under **Settings** > **Organization** in Tallyfy. Copy the ID shown there and include it in your message. See also: [Find your Tallyfy IDs](/products/pro/miscellaneous/how-to-find-your-tallyfy-ids/). Including both details lets the support team jump straight to the exact item you're asking about. - **[Share screenshots](https://tallyfy.com/products/pro/miscellaneous/support/how-to-share-screenshots-and-screencasts-with-tallyfy-support/)**: Sending screenshots or short screen recordings to Tallyfy support helps resolve issues far quicker than text alone. Free tools like Loom or Screencastify and built-in OS shortcuts make it easy. ## Sharing screenshots and screencasts with support A screenshot or short screen recording of your issue helps the Tallyfy support team understand the problem. It's much faster than a text description alone. ### Taking screenshots * **On a Mac** - Press `Shift + Command (⌘) + 3` to capture your entire screen. Use `Shift + Command + 4` to select a specific area instead. * **On Windows** - Press the `PrtScn` (Print Screen) key (you might need `Fn` or `Ctrl` on some keyboards). This copies the screen to your clipboard, so you can paste it into Paint or directly into your support message. There's also the built-in Snipping Tool for more precise captures. ### Recording screencasts If your issue involves multiple steps or something moving on screen, you'll find a short video works better. Here are some free tools: * **Loom**: [https://www.useloom.com/](https://www.useloom.com/) - popular Chrome extension * **Screencastify**: [https://www.screencastify.com](https://www.screencastify.com/) - another widely-used Chrome extension * **Recordit**: [http://recordit.co/](http://recordit.co/) - quick and simple screen recordings These tools let you record your screen (and optionally your voice) and share a video link with the support team. - **[Not receiving emails?](https://tallyfy.com/products/pro/miscellaneous/support/not-receiving-emails-from-tallyfy-how-to-troubleshoot/)**: If Tallyfy emails aren't arriving, check spam folders, notification settings, and have your IT team allowlist tallyfy.com. Use diagnostic tools like Message Trace and mail-tester.com to identify authentication or filtering issues. ## Not receiving emails from Tallyfy When you or your [guests](/products/pro/documenting/guests/) stop receiving emails from Tallyfy, several things could be blocking delivery. Here's how to fix it. ### Allowlisting guides for IT teams These official resources have 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, check their documentation on adding domains to a safe sender list. ## Troubleshooting Microsoft email systems Microsoft email systems (Outlook.com, Hotmail, Office 365, Exchange Online) use aggressive spam filtering that sometimes blocks legitimate emails. Here's how to diagnose and fix these issues. ### Microsoft's two email systems Microsoft runs two separate email infrastructures - knowing which one applies to you matters: **Consumer services** (Outlook.com, Hotmail, Live, MSN): - Personal accounts ending in @outlook.com, @hotmail.com, @live.com, @msn.com - Sender reputation tracked through SNDS (Smart Network Data Services) - Users can mark emails as spam or not spam **Business services** (Office 365, Exchange Online, Microsoft 365): - Corporate and educational domains like @yourcompany.com or @university.edu - Uses Exchange Online Protection (EOP) spam filtering - Managed by your organization's IT administrators The troubleshooting steps differ depending on which system is blocking your emails. ### 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: Good reputation - emails should deliver normally - Yellow: Some issues detected - delivery may be degraded - Red: 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 SNDS only covers consumer services - it won't help diagnose Office 365 issues. ### Business services - working with IT administrators Office 365 and Exchange Online filtering happens at the organization level. Your IT admin 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's servers - Spam Confidence Level (SCL) scores assigned to emails - Which filtering rules blocked delivery - Whether emails went to inbox, junk folder, or quarantine **Typical findings**: - SCL 5-6: 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 a 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 works: **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 it: **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 a mitigation request if blocked **Delist process**: - Provide a detailed explanation of how you resolved the issue - Wait 24-48 hours for Microsoft review - Monitor SNDS for reputation improvement - Consider requesting a dedicated sending IP from Tallyfy for isolated reputation 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 useful diagnostic info: **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 admin can extract and interpret these headers through Message Trace or by viewing the email source. ### Preventative measures These practices help maintain good email deliverability over time: **For users**: - Don't 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 the Focused tab - Report persistent issues to your IT team promptly **For IT administrators**: - Allowlist the tallyfy.com domain rather than individual addresses - Monitor quarantine for false positives - Review spam policies quarterly - Document Tallyfy as an approved business system **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 - Remove bounced addresses to keep lists clean - 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 the 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. ### Terms legals - **[Accessibility statement](https://tallyfy.com/products/pro/miscellaneous/terms-legals/accessibility-statement/)**: Tallyfy's product documentation aims to meet the WCAG 2.2 Level AA accessibility standard. See what's built into every page, how we test the docs, and how to report any accessibility problem you run into. ## We want everyone to use these docs Tallyfy's product documentation should work for everyone, including people who browse with a keyboard alone, a screen reader, screen magnification, voice control, or another assistive technology. This page explains how accessible the docs are today, what we've built in, and how to reach us if something gets in your way. ## How accessible these docs are These docs aim to meet WCAG 2.2 Level AA. That's the accessibility standard most governments and large buyers ask for, and it's the same level Tallyfy targets across the rest of the product. Today the documentation site meets that level, and we don't know of any outstanding issues. We recheck this as we add and change pages, so it stays true over time. ## What's built in You don't have to switch any of this on. It's part of every page: * You can reach and operate every link, button, and menu with the keyboard alone. * Headings, lists, and tables are marked up so a screen reader announces them correctly. * Text and controls meet AA contrast targets in both light and dark mode. * Links say where they go, so they still make sense when read on their own. * Diagrams carry a text description, and none of them flash or loop. * Footnote markers and the copy buttons are large enough to tap on a phone. * Dark mode and your browser's text zoom both work without breaking the layout. ## Known issues We don't currently know of any accessibility problems on these docs. We recheck as we add and change pages, and if you run into something that's hard to use, please tell us (the next section shows how). We treat it as a bug. ## Tell us about a problem Found a page that's hard to read or use? Email us at [support@tallyfy.com](mailto:support@tallyfy.com). Tell us the address of the page and what went wrong, and add the browser or assistive technology you were using if you can. We read every message, and we'll fix the page or get you the same information another way. ## More about Tallyfy and accessibility This page covers the documentation site. For accessibility across the rest of Tallyfy, and to request a full accessibility conformance report (a VPAT), see Tallyfy's main accessibility page at [https://tallyfy.com/legal/accessibility/](https://tallyfy.com/legal/accessibility/). ## Technical details For anyone who wants the specifics: the docs are built with standard HTML, CSS, and JavaScript, and we use ARIA only where a plain HTML element won't do the job. We test against WCAG 2.2 Level A and AA with a mix of automated and manual checks. The automated checks run the axe testing engine in both light and dark mode. The manual checks cover keyboard-only navigation and a review of the accessibility tree that screen readers read from. We test in current versions of Chrome, Firefox, Safari, and Edge. This statement was last reviewed in June 2026. - **[Country restrictions](https://tallyfy.com/products/pro/miscellaneous/terms-legals/is-your-country-blocked-from-using-tallyfy/)**: Tallyfy must follow US trade sanctions, which block access from Cuba, Iran, Syria, North Korea, and other restricted locations. Users who think they qualify for an exception can contact the team to discuss options. ## Countries that can't access Tallyfy As a US corporation, Tallyfy must comply with US trade sanctions. This means access from certain countries is restricted. We're sorry for any inconvenience. ### Blocked locations These locations can't currently access Tallyfy: * **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 think your situation qualifies for an exception, please [contact our team](https://tallyfy.com/contact-us/) to discuss possible 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 covers how we collect, use, and protect your personal information. The compliance page details IT infrastructure and data protection measures. ## Tallyfy's privacy policy Tallyfy's privacy policy explains how we collect, use, and protect your personal information. It's available here - [https://tallyfy.com/legal/privacy-policy/](https://tallyfy.com/legal/privacy-policy/). ### Security documentation For details on our IT infrastructure, security protocols, and compliance practices, here's our compliance page - [https://tallyfy.com/legal/compliance-security/](https://tallyfy.com/legal/compliance-security/). You'll find information on security standards, data protection measures, and operational safeguards. ### Troubleshooting - **[Clear cache in Chrome](https://tallyfy.com/products/pro/miscellaneous/troubleshooting/clear-cache-chrome/)**: Clear Chrome's cache to fix Tallyfy display problems, loading errors, and outdated content. This forces the browser to download fresh files from Tallyfy's servers. ## How to clear Chrome's cache for Tallyfy If Tallyfy pages won't load, look outdated, or behave strangely, clearing Chrome's cache is the fastest fix. It wipes stored files and forces Chrome to pull fresh content from Tallyfy's servers. :::tip[Keyboard shortcut] Press **Ctrl+Shift+Delete** (Windows/Linux) or **Cmd+Shift+Delete** (Mac) to jump straight to the Delete browsing data dialog. ::: ### After clearing the cache Close Chrome completely, then reopen it before going back to Tallyfy. Don't just open a new tab. Quit the browser and restart it. :::note[Common issues this fixes] - Pages not loading or displaying correctly - Login difficulties - Forms not submitting - Seeing old content instead of updates ::: ### Still having problems? If clearing the cache didn't help, [contact Tallyfy support](https://tallyfy.com/contact-us/) for further troubleshooting. - **[Clear cache in Edge](https://tallyfy.com/products/pro/miscellaneous/troubleshooting/clear-cache-edge/)**: Clearing Microsoft Edge's browser cache removes outdated or corrupted temporary files that cause Tallyfy to display incorrectly or run slowly. Clear all browsing data through Edge's Privacy settings, or target only Tallyfy-specific cookies through the address bar's lock icon. ## Clearing Edge's cache to fix Tallyfy issues If Tallyfy isn't displaying correctly or feels slow in Microsoft Edge, clearing your browser cache often fixes it. This removes temporary files that may be corrupted or outdated, forcing Edge to download fresh content from Tallyfy's servers. You can also press **Ctrl+Shift+Delete** (Windows/Linux) or **Cmd+Shift+Delete** (Mac) to jump straight to step 5. ### After clearing Edge's cache Close Edge completely and reopen it before accessing Tallyfy again. This makes sure all cached data is fully removed. ### Clearing cache for only Tallyfy in Edge If you'd rather clear data just for Tallyfy without affecting other sites: ### If clearing cache doesn't resolve the issue If clearing Edge's cache doesn't fix your Tallyfy problems, [contact Tallyfy support](https://tallyfy.com/contact-us/) for further help. - **[Clear cache in Firefox](https://tallyfy.com/products/pro/miscellaneous/troubleshooting/clear-cache-firefox/)**: Clearing Firefox's cache and cookies through the Privacy & Security settings removes outdated or corrupted temporary files. This lets Tallyfy load fresh content and resolves display or loading problems. ## Clearing Firefox's cache to fix Tallyfy issues If Tallyfy isn't loading properly or shows outdated content in Firefox, clearing your cache forces the browser to download fresh files from Tallyfy's servers. ### After clearing the cache Close Firefox completely and reopen it before going back to Tallyfy. This ensures the browser fully clears all old cached data. ### If clearing cache doesn't fix the issue If clearing Firefox's cache doesn't solve your Tallyfy problems, [contact Tallyfy support](https://tallyfy.com/contact-us/) for further help. - **[Clear cache in Safari](https://tallyfy.com/products/pro/miscellaneous/troubleshooting/clear-cache-safari/)**: Clear Safari's cache on Mac and iOS to fix loading problems and display issues in Tallyfy. You'll find steps for the Develop menu, Privacy settings on Mac, and Safari settings on iOS. ## Why clear Safari's cache? Safari stores temporary files to speed up browsing, but these can become corrupted or outdated, causing loading problems, display glitches, or stale content in Tallyfy. Clearing the cache forces Safari to download fresh files. The steps differ between Mac and iPhone/iPad. ### Clear Safari cache on Mac You can also use the keyboard shortcut **Option + Command + E** to empty caches quickly. #### Clear all website data ### Clear Safari cache on iPhone or iPad ### After clearing the cache Close Safari completely and reopen it before visiting Tallyfy again, so you're sure all old cached data is gone. ### Still having issues? If clearing the cache doesn't fix the problem, check the [Tallyfy troubleshooting guide](/products/pro/miscellaneous/troubleshooting/) for more solutions or [contact Tallyfy support](https://tallyfy.com/contact-us/). ### Tutorials - **[Create an organization](https://tallyfy.com/products/pro/tutorials/how-can-i-create-a-new-tallyfy-account/)**: Tallyfy lets you sign up with email or Microsoft/Google accounts to create or join an organization workspace. You'll get a guided welcome task, support options, and troubleshooting for common authentication issues. ## Sign up for Tallyfy and create your organization To start using Tallyfy, you'll create a user account first. This account lets you set up your company's workspace (an organization) or join one that already exists. Learn more [about Tallyfy](/products/pro/miscellaneous/about-tallyfy/). When you create a new organization, Tallyfy assigns you a welcome [task](/products/pro/tracking-and-tasks/tasks/) that walks you through the basics. You can ask questions by commenting on this task, or book a free call with support at [https://tallyfy.com/booking/](https://tallyfy.com/booking/). ### Microsoft sign-in requiring admin approval If you see "Need admin approval" when signing in with Microsoft - your organization has restricted which apps employees can access. 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. Alternatively, 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. This only needs to happen once for your entire organization. For more details, see [Microsoft's documentation on admin approval](https://learn.microsoft.com/en-us/answers/questions/1497998/need-admin-approval-popup). A central system ([account.tallyfy.com](https://account.tallyfy.com)) manages your Tallyfy login and handles sign-ins and password resets for all Tallyfy products. If you're later invited to join other Tallyfy organizations (e.g., a client's or partner's), you can [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's automation rules use simple IF-THEN logic to adapt workflows at runtime. You can hide and reveal onboarding steps based on a new hire's role selection in a form field, so processes self-adjust without manual work. ## Automating processes with rules Tallyfy [automation](/products/pro/documenting/templates/automations/) rules let you build "if-this-then-that" logic so your workflows adapt automatically - no manual adjustments needed. ### How automation rules work Every rule has two parts: * **IF** a specific event happens (the *Condition*) - like a task completion, a form field value, or an approval decision... * **THEN** Tallyfy runs a defined action (the *Action*) - like revealing hidden steps, reassigning tasks, or changing deadlines **Example scenario:** In an Employee Onboarding process, you want to show different steps based on whether the new hire is a "Field worker" or an "Office worker". ### Setting up form field automation for onboarding :::note[Use clear automation names] Give your [automation](/products/pro/documenting/templates/automations/) rules descriptive names (e.g., "Show Field Training if Role is Field Worker"). Don't use generic names like "Rule 1". Clear names let you and your team understand each rule's purpose at a glance. ::: Here's what happens at runtime: * Only Step 1 appears at first. * Once the employee picks their role in Step 1, the relevant step (2 or 3) becomes visible and assigned. Assignees get automatic notifications. * Assignees click the [task](/products/pro/tracking-and-tasks/tasks/) link in their email to complete their step. - **[Franchise operations guide](https://tallyfy.com/products/pro/tutorials/franchise-operations/)**: Tallyfy transforms franchise operations by converting static SOPs into active tracked workflows that franchisees actually run across all locations, with auto-assigned tasks, deadline tracking, and real-time compliance visibility. It supports either distributed or centralized account models where each franchisee maintains a paid private workspace to protect proprietary processes. ## 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) Tallyfy turns scattered franchise SOPs - PDFs, spreadsheets, paper binders - into living workflows that franchisees actually run, not just read. Here's the critical difference: 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 make sure every franchise follows the same pool cleaning protocol - and track that it's actually happened. ## Two deployment models ### Model 1: distributed purchasing (recommended) Each franchisee buys their own Tallyfy account. This gives them: - Full control over templates and customization - Independent billing and user management - Ability to edit HQ-provided templates for local needs - Private 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 paid accounts for security[^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 Direct template copying between Tallyfy organizations currently requires an API-based approach. There isn't a built-in UI feature for this yet: 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. :::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. That's why paid accounts are essential. They give you: - **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 You wouldn't want competitors seeing exactly how you onboard customers or train staff. That's why each franchisee needs their own paid workspace. ## Beyond documentation - running live processes Traditional franchise manuals sit on shelves. Tallyfy templates become active workflows: - **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 confirm every location completed their daily opening checklist. A fitness franchise knows which clubs did equipment maintenance on schedule. The gap between reading an SOP and running it in Tallyfy directly impacts your margins. ## Free SSO for all franchise accounts [Single Sign-On (SSO)](/products/pro/integrations/authentication/) comes free with every Tallyfy account - regardless of which deployment model you pick: - 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 ## Measuring franchise performance Tallyfy gives franchise operations 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 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 experience 5. **Time savings**: Manual processes complete 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 admin. ## Getting started ### 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**: Contact the [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 - **[Welcome snippets](https://tallyfy.com/products/pro/tutorials/how-to-create-a-custom-onboarding-snippet/)**: Tallyfy lets you build custom onboarding snippets that show personalized welcome messages or permanent homepage announcements. Create reusable content blocks in your organization settings and assign them to appear once at first login or continuously for everyone. ## Create a custom onboarding snippet Tallyfy [Snippets](/products/pro/documenting/templates/snippets/) let you create personalized welcome messages and instructional content for new team members. You'll configure them in **Settings > Organization > Personalization** under two options: * **MEMBERS - JUST JOINED**: This snippet appears **only the first time** a new [member](/products/pro/documenting/members/) logs in after accepting their invite. It's ideal for one-time welcome messages, links to training videos, or key onboarding documents. * **MEMBERS - HOMEPAGE**: This snippet **always shows** on the Tallyfy homepage for *all* members in your organization. Use it for ongoing announcements, links to company resources, or support information. ### Setting up a welcome snippet That's it. Your chosen snippet will now appear in the right spot for your members. - **[Workflow applications](https://tallyfy.com/products/pro/tutorials/industry-specific-workflow-applications/)**: Tallyfy's template system with conditional logic and audit trails lets organizations in regulated industries build compliant workflows that capture every action with user identity and timestamps. ## How does Tallyfy address industry-specific workflow requirements? **Important** - this article isn't legal advice. Do your own research and use this content at your own risk. Tallyfy's flexible template system and conditional logic let organizations build workflows that fit their industry - whether that's financial services, healthcare, manufacturing, or another regulated sector. Instead of forcing generic processes, Tallyfy adapts through configurable automations, conditional branching, AI template generation, and full audit trails. ## 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 - **Branch-specific procedures** - location-based automations for multi-branch operations - **BSA training tracking** - completion verification for regulatory audits **Marketing approval workflows**: - **Regulatory checkpoints** - all marketing materials need compliance officer approval before publication - **Interest rate verification** - automated checks to confirm advertised rates match current offerings - **Multi-stage approvals** - commercial, legal review, and final authorization sequences - **Audit trail** - full documentation for regulatory examinations **Account creation and management**: - **Standardized procedures** - consistent account setup across different personnel - **KYC (Know Your Customer)** - systematic identity verification workflows - **AML (Anti-Money Laundering)** - built-in checks and documentation requirements - **Cross-training** - 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/) ### 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 picks the right documentation requirements - **Progressive information gathering** - initial assessment followed by detailed data collection as needed - **Tribal knowledge preservation** - expert knowledge captured in repeatable procedures **Claims processing and risk assessment**: - **Conditional routing by 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 the right decision makers - **Carrier compliance** - automated adherence to specific carrier protocols ### Asset management firms Asset management companies face extensive audit trail requirements across multiple jurisdictions. **Investment adviser compliance (SEC Rules 204-2 and 206(4)-7)**: - **Books and records** - every advisory transaction logged with user identity, timestamp, and decision rationale for five-year retention [1] - **Annual compliance review** - written documentation of each 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 [3, 4] **Private fund management (enhanced SEC rules)**: - **Portfolio valuation** - step-by-step workflows capturing valuation methods, responsible parties, and approval chains - **Fee calculation documentation** - detailed trails showing computation logic, supporting data, and authorizing personnel - **Investor reporting** - systematic processes ensuring accurate, timely disclosures with full audit trails **European MiFID II/MiFIR compliance**: - **Transaction reporting** - audit trail systems that reconstruct 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** - 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? Many regulated sectors legally mandate workflows that produce immutable audit trails - logging each task with user identity, timestamp, and outcome. ### Pharmaceutical manufacturing **FDA electronic batch manufacturing records (eBMR)**: Pharmaceutical companies must implement secure audit trail systems capturing every creation, modification, or deletion of critical production data under 21 CFR 211.188(b) [8]. - **Production steps** - each weighing, mixing, and cleaning operation logged with operator identity and timestamp - **Review requirements** - procedures ensuring audit trail review after each significant manufacturing step - **Change control** - all modifications documented with user ID, timestamp, and scientific rationale - **Deviation investigation** - standardized workflows for investigating 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]. - **eCRF workflows** - every data entry and modification logged with investigator identity, timestamp, and reason for change - **Protocol deviation documentation** - procedures for documenting, investigating, and reporting deviations - **Audit trail reviews** - risk-based workflows for periodic review of trial data and metadata integrity - **Regulatory submissions** - complete documentation supporting regulatory filings with full user attribution ### Medical device manufacturing **ISO 13485 quality management system requirements**: Medical device manufacturers must maintain strong document control and traceability systems - every change logged with the responsible individual and rationale [10]. - **Design control** - procedures capturing design inputs, outputs, reviews, and changes with user attribution - **Production records** - batch-specific documentation showing which personnel performed each step - **CAPA processes** - workflows documenting problem identification, investigation, and resolution - **Management reviews** - 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 tasks** - "travelers" or "routers" listing each step with technician signature, stamp, or electronic ID - **Inspection workflows** - ensuring proper inspection and sign-off for each task - **Parts traceability** - documentation of parts installation with serial numbers and responsible personnel - **Return-to-service** - 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]. - **QA documentation** - workflows capturing inspection findings, test results, and corrective actions - **Fitness-for-duty** - processes documenting personnel qualifications with 40-year retention requirements - **Configuration management** - change control ensuring all modifications are properly documented and approved - **Emergency response** - 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]. - **HACCP documentation** - procedures capturing monitoring data, verification activities, and corrective actions - **Preventive controls verification** - regular workflows confirming the effectiveness of implemented controls - **Supplier verification programs** - 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 audit trail systems under 45 C.F.R. section 164.312(b) capturing all electronic protected health information (ePHI) interactions [14]. - **Access logging** - documentation of user log-on/off events, file access attempts, and record modifications - **Breach investigation** - standardized workflows for investigating and documenting potential privacy breaches - **Risk assessment** - regular procedures for evaluating and documenting security risks - **Incident response** - procedures for responding to security incidents with proper documentation ### 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** - time-based logging of operations, bit runs, mud logging, and casing - **Non-productive time tracking** - documentation of delays, equipment failures, and remediation - **Safety incident reporting** - procedures for documenting and investigating safety events - **Environmental compliance** - 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** - each operation logged with operator identity, timestamp, workstation, and quality parameters - **Change control** - documentation of all process changes with technical justification - **Supplier quality** - workflows for monitoring and documenting supplier performance - **Customer complaints** - 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** - procedures capturing employee training with identity, date, and verification methods - **Pre-startup safety reviews** - documenting safety checks before process modifications - **Process hazard analysis** - regular workflows for identifying and documenting process hazards - **Incident investigation** - 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 examinations** - visual inspection with documentation of tracks traversed and hazards identified - **Equipment inspection** - documenting equipment condition and safety compliance - **Hazard abatement** - standardized processes for identifying, documenting, and correcting safety hazards - **Training records** - documentation of miner safety training and certification ### Utilities and infrastructure **NERC CIP cybersecurity requirements**: Electric utilities must implement audit logging systems under NERC CIP-007-6 and CIP-010-5 [19]. - **Security event monitoring** - documentation of user activities on critical cyber systems - **Patch management** - procedures documenting security patch deployment with personnel attribution - **Access control** - workflows managing and documenting system access - **Incident response** - 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** - systems preventing overwriting of original entries while maintaining audit trails - **Sampling documentation** - processes capturing sampler identity, location, environmental conditions, and statistical rationale - **Calibration workflows** - procedures documenting calibration activities with personnel attribution - **Quality control** - 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** - documenting track conditions with inspector identity and findings - **Defect remediation** - standardized workflows for addressing identified track defects - **Equipment inspection** - regular documentation of track maintenance equipment condition - **Training and certification** - 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** - documenting equipment condition with inspector attribution - **Maintenance documentation** - capturing equipment maintenance activities - **Safety incident reporting** - workflows for documenting and investigating construction safety events - **Training records** - procedures ensuring operator qualification and certification ## How does Tallyfy serve professional services industries? ### Legal services Law firms need 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** - case identification and progress monitoring - **Document preparation workflows** - standardized processes for common legal documents - **Billing and time tracking** - 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** - 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** - 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 - **Involved-party notification sequences** - automated alerts to appropriate parties - **Documentation and reporting** - evidence collection and reporting - **Post-incident review procedures** - standardized analysis and improvement identification ## What healthcare and regulated industry applications exist? ### Healthcare operations **Patient care protocols**: - **Treatment pathway workflows** - standardized care sequences for common conditions - **Medication administration** - step-by-step safety checks and documentation - **Discharge planning** - preparation for patient transitions **Regulatory compliance**: - **HIPAA workflows** - privacy and security procedures - **Joint Commission preparation** - processes for accreditation readiness - **Incident reporting** - documentation and analysis workflows - **Staff credentialing** - verification and maintenance procedures ### Manufacturing and quality control **Equipment maintenance protocols**: - **Preventive maintenance** - automated workflows based on equipment type and usage - **Safety procedure compliance** - step-by-step adherence to safety requirements - **Documentation tracking** - record keeping for audits - **Cross-training** - standardized procedures for skill development ## How does Tallyfy handle industry-specific conditional logic? ### Complex decision trees **Progressive information revelation**: - **Kickoff forms with essential data only** - launch with guaranteed available information - **Conditional step revelation** - additional steps appear based on earlier responses - **Just-in-time information gathering** - collect data when it's needed rather than upfront - **Exception handling** - clear procedures for unusual situations **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 variations** - different procedures for different offices or regions, including compliance with [local language requirements](/products/pro/integrations/azure-translation/global-workplace-language-requirements/) - **Client-type specific workflows** - customized procedures based on relationship type ### Regulatory and compliance automation **Audit trail generation**: - **Complete process documentation** - every step tracked with timestamps and responsible parties - **Export for auditors** - easy generation of compliance reports and evidence - **Process version control** - historical tracking of procedure changes and rationale - **Evidence collection** - gathering and organization of required documentation **Risk management integration**: - **Risk-based routing** - higher-risk scenarios automatically escalated to the right 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 **Phase 1 - high-impact, lower-complexity processes** - Start with frequently performed procedures that don't need extensive regulatory review - Focus on processes where consistency directly impacts quality or efficiency - Pick 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 need extensive documentation or approval trails **Phase 3 - complex, multi-department workflows** - Implement processes that span multiple departments or need 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 use existing industry knowledge. **Subject matter expert collaboration**: - Work with internal experts to capture specific 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**: - Make sure workflows comply with industry-specific regulations and standards - Include required documentation and approval steps for compliance - Design audit-ready processes with built-in evidence collection and reporting - Plan for regulatory change management and procedure updates ## Citations [1]: Cornell Law School. "17 CFR § 275.204-2 - Books and records to be maintained by investment advisers." 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." https://www.law.cornell.edu/cfr/text/17/275.206%284%29-7 [3]: FINRA. "7160. Audit Trail Requirements." https://www.finra.org/rules-guidance/rulebooks/finra-rules/7160 [4]: FINRA. "7360. Audit Trail Requirements." https://www.finra.org/rules-guidance/rulebooks/finra-rules/7360 [5]: RBC Capital Markets. "Transaction Reporting Under MiFID II." https://www.rbccm.com/assets/rbccm/docs/news/2017/mifid-4of4.pdf [6]: ACA Group. "MiFID II for Asset Managers: Communications Record Keeping." https://www.acaglobal.com/insights/mifid-ii-asset-managers-communications-record-keeping/ [7]: iCapital. "FinCEN's New AML Rules: What Advisers Need to Know." https://icapital.com/insights/practice-management/fincens-new-aml-rules-what-advisers-need-to-know/ [8]: FDA. "Data Integrity and Compliance With Drug CGMP." https://www.fda.gov/media/119267/download [9]: ICH. "Good Clinical Practice (GCP) E6(R3) Draft Guideline." https://database.ich.org/sites/default/files/ICH_E6%28R3%29_DraftGuideline_2023_0519.pdf [10]: BPRHub. "ISO 13485: Traceability & Identification Requirements." https://www.bprhub.com/blogs/iso-13485-traceability-medical-device-identification [11]: FAA. "AC 145-9A - Advisory Circular." https://www.faa.gov/documentLibrary/media/Advisory_Circular/AC_145-9A.pdf [12]: NRC. "Section 15- Quality Assurance Records." https://www.nrc.gov/docs/ML0605/ML060590368.pdf [13]: Sustainable Agriculture Research & Education. "Food Safety Plan and Recordkeeping - Preventive Controls." 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?" https://compliancy-group.com/hipaa-audit-log-requirements/ [15]: TID Journal. "Daily Drilling Report - Drilling & Well Completion." 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." 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." https://www.osha.gov/laws-regs/regulations/standardnumber/1910/1910.119 [18]: Cornell Law School. "30 CFR § 56.18002 - Examination of working places." https://www.law.cornell.edu/cfr/text/30/56.18002 [19]: NERC. "Standard Development Timeline - CIP-007-X." 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." https://www.demarcheiso17025.com/document/Understanding%20and%20Implementing%20ISO17025.pdf [21]: Cornell Law School. "49 CFR § 213.241 - Inspection records." https://www.law.cornell.edu/cfr/text/49/213.241 [22]: OSHA. "1926.1412 - Inspections." https://www.osha.gov/laws-regs/regulations/standardnumber/1926/1926.1412 - **[Knowledge-only mode](https://tallyfy.com/products/pro/tutorials/knowledge-only-mode/)**: Tallyfy lets you publish procedures as searchable reference materials that teams can access without launching formal processes. Keep content current through comments, embedded templates, snippets, and AI platform integration for instant answers. ## Using Tallyfy for knowledge management Not every procedure needs tracking. Knowledge-only mode lets you publish procedures as reference materials that teams can access without launching formal processes - like entering a sales order or handling customer calls. ### When to use knowledge-only mode Some processes need tracking (client onboarding, compliance audits). Others just need to be accessible and current. **Good fit 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 ### Publishing procedures as knowledge Your team searches for "sales order entry" and immediately finds the latest procedure. No hunting through outdated wikis or shared drives. ### Permissions for knowledge sharing **View-only access** - Grant [Light members](/products/pro/documenting/members/light-members/) permission to view templates without launching them. Great 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. **Guest access for partners** - Share specific procedures with [guests](/products/pro/documenting/guests/) - like suppliers who need to understand your receiving process. They see only what you share. ### Improving knowledge through comments 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 right away. 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 after that. ### Search capabilities Tallyfy's [universal search](/products/pro/miscellaneous/how-to-use-tallyfys-universal-search-function/) finds the right procedure in seconds. Type any keyword and it 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. ### Change management and watching Tallyfy's watching feature lets you monitor specific templates for changes. **Watch frequencies:** - **Instant** - Critical procedures where any change matters right away - **Daily digest** - Batch updates for standard procedures - **Weekly summary** - Low-priority reference materials **What triggers notifications:** - Template content changes - New comments or improvement suggestions - Permission modifications - Automation rule updates ### Embedding templates within templates You can embed one template inside another to eliminate repetition. **Example**: 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, embed the checklist. Create your "Sales call" template and embed "Pre-call checklist" at the beginning. Do the same for "Support call." When you update the pre-call checklist, every template using it updates automatically. 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) ### Snippets for consistent content [Snippets](/products/pro/documenting/templates/snippets/) keep language consistent across all procedures. Create a snippet for your standard confidentiality notice, insert it into 50 templates, and when the legal language changes - update the snippet once and all 50 templates reflect it. **Useful snippets to create:** - Legal disclaimers and compliance statements - Safety warnings and precautions - Contact information blocks - Standard operating conditions - Common troubleshooting steps Everyone uses approved language. Marketing won't accidentally use old taglines. Legal won't find outdated disclaimers. ### AI and MCP integration Connect Tallyfy's knowledge base to any AI platform through the [MCP server](/products/pro/integrations/mcp-server/). An 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 - always pulling from current procedures. **Setup steps:** 1. Enable MCP server in Tallyfy settings 2. Configure your AI platform to connect 3. Set appropriate access permissions 4. Test with common queries ### Practical examples **Entering a sales order** - Your sales team pulls up the procedure during customer calls, follows along, but doesn'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. It's guidance, not governance. **Password reset procedures** - IT publishes step-by-step instructions. Employees follow them independently without creating tickets for simple resets. **Expense report guidelines** - Finance maintains current policies and examples. Employees reference them while completing reports in your expense system. ### Setting up knowledge-only workflows Start with your top 10 most-requested procedures and turn them into searchable templates. ### Measuring effectiveness **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) **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 patterns **Versioned procedures** - Keep previous versions accessible but clearly marked. Sometimes you need to know what the procedure was last quarter for audit purposes. **Conditional 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. **Analytics integration** - Export view and search data to your [BI platform](/products/pro/integrations/analytics/) to understand which procedures drive value and which need retirement. **Collaborative building** - Use comments and [variables](/products/pro/documenting/templates/variables/) to crowdsource improvements. Teams contribute examples that make procedures clearer. ### Best practices **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. **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. **Retire outdated content** - Archive obsolete procedures clearly. Don't let old versions create confusion. - **[Navigate Tallyfy](https://tallyfy.com/products/pro/tutorials/navigate-tallyfy/)**: Tallyfy's interface centers on a left sidebar menu for quick access to processes, templates, tasks, and people management. A universal search bar at the top finds anything across your account. ## How to get around the Tallyfy interface Tallyfy has several key interface areas for finding information and managing tasks. ### What's the left sidebar menu? The left sidebar is your main navigation in Tallyfy. ![Tallyfy left sidebar menu with numbered sections](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-sidebar-numerated.png) 1. **+ CREATE**: Start new processes, templates, or tasks 2. **HOME**: Go to your dashboard 3. **TASKS**: See your task assignments ([learn more](/products/pro/tracking-and-tasks/tasks/)) 4. **TRACKER**: View all active processes ([learn more](/products/pro/tracking-and-tasks/tracker-view/)) 5. **TEMPLATES**: Access your template library ([learn more](/products/pro/documenting/templates/)) 6. **PEOPLE**: Manage team members (Administrators only) 7. **INVITE+**: Invite new members to your organization 8. **GUIDE**: Open help documentation 9. **SUPPORT**: Contact the support team 10. **SETTINGS**: Access personal and organization settings :::note[Visibility depends on your role] Some sections like **People** or certain **Settings** aren't visible to all users. Standard and Light roles have different access levels. ::: ### How does universal search work? ![Tallyfy universal search bar showing results](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-search-bar-results.png) The search bar at the top lets you find anything across your Tallyfy account: processes, templates, tasks, snippets, and team members. Just type keywords. * **Sharing results**: There's a share icon next to each search result. Click it to copy a direct link to that item. ![Copy link button next to a Tallyfy search result](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-copy-search-result-link.png) ### What are the top bar icons? * **Language selector** (Globe icon): Click to change the display language for 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. ![Tallyfy language selector dropdown](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 activity. See [Check Notifications](/products/pro/tracking-and-tasks/how-can-i-view-notifications-in-tallyfy/). - **[Why training fails](https://tallyfy.com/products/pro/tutorials/why-documentation-training-fails-forgetting-curve/)**: Humans forget 90% of learned information within seven days. Instead of relying on memory and training, Tallyfy guides people step-by-step through every process at the exact moment they need it. ## The Ebbinghaus forgetting curve In 1885, psychologist Hermann Ebbinghaus discovered that we forget information at an exponential rate. His research, replicated many times including a [2015 study](https://pmc.ncbi.nlm.nih.gov/articles/PMC4492928/), established 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 keep investing in training programs and documentation 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 people lose information over time without reinforcement. Ebbinghaus memorized nonsense syllables (like "WID" or "ZOF") to eliminate prior knowledge effects, then measured relearning effort after various intervals. **Three key insights:** 1. **Forgetting is exponential, not linear** - the steepest decline happens in the first hour 2. **Sleep creates a retention bump** - memory slightly improves after 24 hours due to sleep consolidation 3. **Without reinforcement, nearly everything is forgotten** - after a month, retention approaches zero ### Impact on business operations Typical business knowledge transfer looks like this: - **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 completed once per year - **Expert knowledge transfer** - sitting with experienced staff to learn procedures According to the forgetting curve, **90% of this investment is wasted**. By the time employees need 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 learn information in advance, store it in memory, and retrieve it perfectly when needed. This fails because: - **Time gap** - days or weeks 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 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 - Knowledge walks out the door when experts leave - Execution becomes inconsistent as each expert develops their own methods ### Industry examples #### Healthcare - Nurses receive intensive orientation on medication protocols - Months later, facing a rarely-used medication, critical steps are forgotten - Result: medication errors - one of the leading causes of patient harm #### Financial services - Extensive compliance training on anti-money laundering procedures - When suspicious activity occurs, staff forget specific reporting requirements - Result: regulatory violations, fines, reputational damage #### Manufacturing - Safety procedures taught during onboarding - Workers skip critical safety steps they can't recall - Result: workplace accidents, production delays, liability issues - Multinational facilities face extra challenges when training happens in non-native languages - forgetting effects are magnified #### Professional services - Complex client onboarding procedures explained in training - Steps are missed or performed incorrectly months later - Result: client dissatisfaction, rework, lost revenue ### Neuroscience insights Modern neuroscience has validated Ebbinghaus's findings: #### Working memory limitations - Human working memory holds only 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 retrieval - Language barriers compound these challenges - employees struggle to recall procedures explained in non-native languages, especially under pressure ### Overcoming the forgetting curve Instead of relying on memory, successful organizations: #### 1. Remove the need to remember Guide people through each step in real-time instead of hoping they recall training: - **Just-in-time guidance** - instructions at the moment of need - **Progressive disclosure** - only relevant information for the current step - **Contextual help** - explanations and resources embedded in 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 simple and gradually increase sophistication - **Feedback loops** - immediate confirmation of correct actions ### How Tallyfy bypasses the forgetting curve Tallyfy succeeds because it **bypasses memory entirely**. Instead of asking people to remember procedures: **Real-time guidance** - Step-by-step instructions appear exactly when needed - No time gap between learning and doing - Context-specific help for each situation **Consistency through structure** - Required fields ensure nothing is missed - Conditional logic handles variations automatically - Approval workflows prevent unauthorized deviations **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 **Institutional memory** - Knowledge lives in the system, not individual minds - Process history provides learning examples - Updates propagate instantly to all users ### 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 **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 - Help employees succeed without perfect memory By providing real-time guidance exactly when needed, workflow systems like Tallyfy bypass memory limitations entirely. Organizations that accept this reality and design around it achieve consistent execution, reduced errors, and sustainable growth. - **[Launch a process](https://tallyfy.com/products/pro/tutorials/your-first-process/)**: Launch a process in Tallyfy by clicking Launch Process on any template card and naming the instance. You can optionally edit assignees and deadlines before launching, then track progress automatically through the Tracker view. ## How to launch your first process Here's how to launch a [process](/products/pro/tracking-and-tasks/processes/) from a [template](/products/pro/documenting/templates/) you've already created. A process is a running instance of your template - think of the template as a blueprint and the process as a live, trackable copy. :::tip[Need to add tasks later?] 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 - even if they weren't in the original template. ::: - **[Create your first template](https://tallyfy.com/products/pro/tutorials/your-first-template/)**: Tallyfy templates are reusable process blueprints you can build in minutes. Describe what you need and AI generates structured steps, or build from scratch and upload existing SOP documents. ## What's a 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) Templates are reusable blueprints for repeatable processes. Build one, then run it consistently every time. ### Create a template with Tallyfy AI The fastest way to build a template is with Tallyfy AI: ### Other creation methods * **From scratch** - Build steps manually for full control over every detail. * **From SOP document** - Upload a Word doc, PDF, or flowchart. Tallyfy AI converts it into a structured template. See [Create a template](/products/pro/documenting/templates/create-template/) for details on all methods. - **[Key features](https://tallyfy.com/products/pro/tutorials/features/)**: Tallyfy turns static process documentation into dynamic, trackable workflows. Key features include real-time status tracking, conditional logic automation, guest collaboration, and process optimization tools. ## Key platform features Tallyfy includes features for real-time status tracking, workflow automation through conditional logic, external guest collaboration, and process optimization. These turn static documentation into dynamic, trackable workflows. ## Browse features You'll find details in the feature pages below: ## Get personalized help To discuss discounts or specific help you need, [schedule a chat with us](https://tallyfy.com/booking/) for direct support. - **[How-to guides](https://tallyfy.com/products/pro/tutorials/how-to/)**: Tallyfy's how-to guides provide task-focused step-by-step instructions showing how to combine features to solve real-world workflow challenges. They help your team work more productively with practical approaches. ## What are Tallyfy's how-to guides? These guides show you how to solve common workflow challenges using Tallyfy. Each one covers a specific business situation and walks you through an effective approach. They're a complement to the feature documentation, showing how you can combine Tallyfy's features to tackle real-world problems. ### Available guides ### Why use these 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 improvement** - ideas for making your business workflows more effective Have a suggestion for a how-to guide you'd find helpful? Contact the Tallyfy support team. ### Features - **[Customer-facing workflows](https://tallyfy.com/products/pro/tutorials/features/customer-facing/)**: Tallyfy lets external people like clients and vendors join your workflows through secure email links without accounts or passwords. You can invite unlimited guests for free with your own branding and automatic reminders. ## How can I work with external guests in Tallyfy? Tallyfy's **Guest** feature lets external people - customers, clients, vendors, partners - join your workflows. They don't need to create an account or manage passwords. ### What 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. There's no account or password required. * **One link per person** - Each guest email (e.g. jane.doe@gmail.com) maps to one specific link that won't change. They can access all tasks assigned to their email through 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** - A guest can pass their task to someone else on their team by adding the new person's email. * **Unlimited and free** - Invite as many guests as you need at no extra cost. * **Automatic reminders** - Guests get email reminders for upcoming or overdue tasks, and they can adjust how often they're reminded. - **[Fill in the blanks](https://tallyfy.com/products/pro/tutorials/features/fill-in-the-blanks/)**: Build smart templates with locked standard text and editable fill-in-the-blank fields instead of cloning documents. Tallyfy also supports reusable snippets and variables that pull in previously collected data across your workflows. ## 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 lets you create smart **[Document Templates](/products/pro/documenting/documents/)**. ### How can I set what people can change? 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 template, they fill in those blanks - everything else stays consistent. ### How can I reuse standard text blocks with snippets? If you have standard paragraphs (like legal text or company info) used across many documents, create a [**Snippet**](/products/pro/documenting/templates/snippets/) with that text. Insert it into multiple document templates - and when the text changes, edit the snippet *once*. The update appears everywhere it's used. ### How can I pull in data automatically using variables? When you've 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. You enter data once but it can appear in multiple places - reducing errors and saving time, especially for contracts. - **[If-this-then-that](https://tallyfy.com/products/pro/tutorials/features/if-this-then-that/)**: Tallyfy lets non-technical teams automate workflow decisions using plain-language if-this-then-that rules that can change assignments and deadlines or show and hide steps based on form inputs and task states. These rules replace confusing flowcharts with simple conditional logic anyone can manage. ## 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](https://screenshots.tallyfy.com/illustrations/create-automation.jpeg) Tallyfy uses "if-this-then-that" rules (also called automations) to make decisions and trigger actions in your processes automatically. Your workflows respond to changing conditions, user inputs, and process states - without manual intervention or coding. ### Why simple rules instead of flowcharts? Complex flowcharts confuse business users and are hard to maintain. Tallyfy's clear if-this-then-that statements are easier to read, manage, and stay accessible to all team members - even for sophisticated scenarios with multiple conditional branches. ### Do I need programming skills? No. You don't need any programming expertise. You can set up rules like "IF the amount exceeds $500, THEN show the manager approval step" through a simple configuration screen. ### Can teams manage their own rules? Yes - teams can adjust their own workflow logic and don't need IT help every time something changes. ### How does this connect to other tools? While they're simple to create, rules can trigger actions in other systems using Tallyfy's API, Middleware, or Webhooks. ### What actions can rules trigger? - Change task assignments - Adjust task deadlines - Show or hide steps - Re-open completed tasks ### How can I convert existing flowcharts? If you have existing flowcharts, Tallyfy's AI import tool can help turn them into runnable templates. - **[Explain it once](https://tallyfy.com/products/pro/tutorials/features/explain-it-once/)**: Tallyfy templates let you define a process once and run it identically across your team every time. AI-assisted creation, document conversion, conditional logic, and multilingual support eliminate repeated explanations and ensure consistent quality. ## 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 are built around the "Explain it Once" idea - you define a process once, then every team runs it the same way. There's no need to repeat yourself. Teams follow identical steps every time, which cuts training time and prevents the quality problems you'd get from everyone doing things differently. ### What template creation methods and features does Tallyfy offer? Tallyfy provides several ways to create and manage templates: * **AI-assisted creation** - Build 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/). If you operate internationally, review [global workplace language requirements](/products/pro/integrations/azure-translation/global-workplace-language-requirements/) for compliance with local regulations. * **Works on any device** - Templates and processes automatically adjust to 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 update templates over time. * **Template maintenance** - Set reminders 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. - **[Migration guide](https://tallyfy.com/products/pro/tutorials/features/migrate-to-tallyfy/)**: Use open-source migrator scripts to move data from 15+ platforms like Asana, Trello, Monday.com, and Process Street into Tallyfy. Supports dry-run, checkpoint resume, and AI-assisted field mapping. ## How do I migrate data from other platforms to Tallyfy? Move from popular workflow and form tools into Tallyfy using 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. ::: :::note[Custom fields vs form fields when migrating] The tool you're migrating from probably calls its form inputs "custom fields". Those hold data people typed in, so they map to Tallyfy [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) (the API name is `captures`). That's what the mapping below does. Tallyfy also has a separate feature named [custom fields](/products/pro/integrations/open-api/custom-fields/): organization-defined metadata you attach to a record like a process, member, or guest. The migrator doesn't write source data there. If you'd rather store migrated values as record metadata, set them with the custom fields API after the migration finishes. ::: ### 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 ## Vendor-by-vendor notes and caveats Each folder links to the open-source code for that vendor, with 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 aren't 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**: Big 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 don't 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. - **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 and fix 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 mapping 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 migrated data lands in Tallyfy Migrated structures become Tallyfy [templates](/products/pro/documenting/templates/). From there, you [launch processes](/products/pro/launching/) and track them 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 automatic live tracking of every running workflow so you can see exactly who is working on what and where things stand at any moment. It eliminates status meetings and the need to chase people for updates. ## How does Tallyfy show real-time process status? ![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 - so you can stop chasing people for updates. You'll see exactly where things stand at any moment, which **eliminates status meetings** entirely. ### How does real-time tracking eliminate status meetings? Traditional workflows depend on frequent status meetings where managers ask "What's the status of this?" These meetings exist partly because people forget process details. Tallyfy's real-time visibility makes them unnecessary. **Instead of status meetings, you get:** - **Package tracking for workflows**: Just like tracking a FedEx package, you can see exactly where each process stands without asking anyone - **Relay race visibility**: Clear view of who has the "baton" and what's coming next in the sequence - **"Don't ask me that again" transparency**: 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 next - no meetings needed - **Built-in accountability**: Tasks sit visibly in the system until completed, so "I forgot" isn't possible - **Clear handoffs**: You can see exactly when one person finishes and the next person's work begins ### How does automatic progress tracking work? Tallyfy instantly updates process status whenever someone completes a task. You'll see completed work, active tasks, and upcoming activities - all without anyone sending email updates or chat messages. No information delays, no stale status reports. ### How do automatic notifications keep workflows moving? Tallyfy automatically alerts team members when tasks become available - through both email and in-app notifications. No manual follow-up needed. Workflows keep moving without managers having to chase people down. ### How does Tallyfy make analysis and improvement easier? Because Tallyfy uses standard templates, tracking how long processes and steps take is far more consistent than emails or spreadsheets. That consistency helps you: * Compare different runs of the same process for performance patterns * Spot bottlenecks or steps causing delays * Measure whether changes actually improve the process with real data * Make better decisions based on facts rather than assumptions ### How does Tallyfy deliver more predictable results? Documented, trackable processes in Tallyfy lead to more consistent outcomes than scattered emails or simple to-do lists. Standardized workflows, clear accountability, and systematic execution remove the variability that comes with ad-hoc work management. - **[Structure intake](https://tallyfy.com/products/pro/tutorials/features/structure-intake/)**: Tallyfy turns form submissions into the first step of a structured workflow. Data flows automatically into later steps, giving everyone real-time visibility without manual follow-ups. ## How does integrated form and process management work? Tallyfy connects [forms](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) directly to later workflow [steps](/products/pro/tracking-and-tasks/processes/), turning separate form submissions into the first step of a structured, trackable process. You'll get full visibility and accountability from submission to completion. ### How does form-to-process integration work? Tallyfy 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 captures, routes, and tracks all incoming requests from start to finish. ### How does Tallyfy provide visibility throughout the process lifecycle? With standalone forms, visibility stops after submission. Tallyfy provides ongoing status tracking for everyone involved - both internal and external - so there's no need for manual follow-ups about submission status. ### How does data continuity work throughout processes? Information collected in kick-off forms stays 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? Tallyfy includes validation features to 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 - whether they're web forms, Word/Excel/PDF docs, or paper forms - into Tallyfy. Conversion tools can help with the migration. - **[Tickets vs. Processes](https://tallyfy.com/products/pro/tutorials/features/ticket-driven-vs-process-driven/)**: Ticket-driven workflows rely on unstructured requests with no guaranteed consistency. Tallyfy replaces this with structured processes using intake forms, automatic routing, clear ownership, and built-in follow-ups. ## How do ticket-driven workflows 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 work like separate conversations started through different channels: * Email to a specific address for formal requests * Social media for public inquiries * Phone calls for urgent matters * Chat messages on a website or app for quick help :::warning[The shared inbox problem] Shared inboxes have the same flaws as ticket systems - they're unstructured chaos pretending to be organization. Teams dump emails into a shared inbox hoping someone handles them, but you get: - **No structured data**: 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 improve Both tickets and shared inboxes are 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. 3. **Gathering information**: Collecting more details if the initial info isn't enough. 4. **Solving the issue**: Responding with a solution and closing the ticket. 5. **Optional root cause check**: Looking into underlying problems that might need fixing. 6. **Optional feature consideration**: Deciding if the issue suggests product improvements. 7. **Optional help docs update**: Checking if documentation needs updating. This model has real downsides: * Teams often skip steps 5-7 due to time constraints or lack of enforcement. * Customers can't see ticket status or progress, creating uncertainty. * You'll need manual follow-up if responses are slow. * Service quality depends on whichever agent handles the ticket, creating inconsistency. ## How do process-driven workflows improve operations? Tallyfy turns ticket handling into structured processes with clear steps and accountability. Here's what that looks like: * **Structured intake**: Standard forms collect request details and categorization up front. * **Routing before review**: Requests go to the right teams automatically based on type. * **Using help docs automatically**: Knowledge base info gets applied consistently to responses. * **Involving other teams**: Clear rules define when other departments get involved. * **Linking to improvement processes**: Issues connect directly to product improvement workflows. ## What advantages do process-driven workflows have over tickets? * **Consistent steps**: Every interaction gets the same standard handling. * **Automatic follow-up**: Automated reminders prevent missed steps. * **Processes that scale**: Clear ownership and next steps make it easy to grow. * **Clear progress tracking**: Visual status updates keep everyone informed. * **Customer visibility options**: You can optionally show process status to external people. * **Regular improvement cycles**: Structured review of recurring issues drives product improvement. * **Better help docs**: Systematic reviews catch gaps in self-service documentation. :::tip[The power of structured funnels: before, during, and after] Replacing tickets with structured processes builds 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 captured automatically - 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. Tallyfy processes give you clean, structured data flowing through a predictable funnel. Which would you rather scale? ::: The result? More reliable, flexible, and customer-friendly support operations. ### How to - **[Build effective forms](https://tallyfy.com/products/pro/tutorials/how-to/build-effective-forms/)**: Tallyfy builds forms directly into workflow steps, so every submission triggers a trackable process. Public forms include email verification, and multi-step forms support conditional branching, field validation, document generation, and built-in collaboration. ## 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 wonder what happens after they click submit. Tallyfy connects submission directly to a trackable workflow: - **Submit and track**: Form submission starts the first step of a visible, trackable workflow. - **Process context built in**: Forms start processes that already have defined action steps. - **Full visibility**: Submitters can see status updates, approvals, and downstream task progress after submission. Tallyfy calls these "kick-off forms" because they start processes, not just collect data. ### Email verification for public forms Public forms can cause problems when submitters use fake or wrong email addresses: - **Email verification**: Tallyfy's public kick-off forms verify email addresses to confirm submitters are genuine. - **Secure access links**: Submitters get unique links via email to access and finish forms. - **Ongoing tracking**: Verified submitters can track their submission status later. - **Reduced spam**: Verification cuts down on 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. Each field type supports [validation options](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) to make sure data is complete and correctly formatted. ### Breaking forms into steps Instead of one long form, Tallyfy lets you spread fields across multiple steps: - **Progressive collection**: Gather information step by step. - **Real-time saving**: Entries save as they're typed, reducing lost work. - **Automated reminders**: Tallyfy sends reminders for incomplete steps. - **Better completion rates**: Shorter forms at each stage mean more finished submissions. :::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/) let forms adapt: - **Conditional visibility**: Show or hide steps based on previous answers. - **Targeted questions**: Only ask what's relevant to each situation. - **Less abandonment**: Focused forms lead to higher completion rates. Learn more about [conditional branching](/products/pro/documenting/templates/automations/logic-explained/). ### Field validation - **Input validation**: Check formats for emails, numbers, dates, and more. - **Required fields**: Make sure critical information isn't skipped. - **Character limits**: Set minimum and maximum lengths for text fields. - **Error messages**: Guide users to fix mistakes before submitting. See [validation options per field type](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/#short-text-field) for details. ### Adding help text Tallyfy lets you add guidance text to any form field: - **Field guidance**: Add explanatory text below a field label. - **Examples and tips**: Show formatting hints or sample answers. - **Clear labeling**: Use descriptive labels so users know what's expected. - **Consistent style**: Keep help text formatting the same across your forms. ### 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 - **[Webhooks](/products/pro/documenting/documents/how-to-generate-documents-from-form-fields/)**: Send form data automatically to other systems. - **API connections**: Connect Tallyfy to other business software. - **Document generation**: Auto-fill document templates with form data. - **[Data exports](/products/pro/integrations/middleware/how-can-i-export-form-fields-from-tallyfy-to-spreadsheet/)**: Get form data into spreadsheets or other formats. ### Collaborative form completion - **Assignee management**: Form starters can assign steps to the right team members. - **Guest access**: Include external people securely. - **Task reassignment**: Reassign tasks when someone isn't available. - **Group assignments**: Assign steps to entire teams. - **Parallel completion**: Different parts of a process can be done at the same time. ### Document generation from forms Tallyfy can create documents automatically from form submissions. For example, a form collects client details, project scope, and pricing, then automatically generates a contract PDF. - **Template-based documents**: Fill contracts, letters, or proposals with form data. - **Dynamic content**: Documents change based on form answers. - **Formatted output**: Generate branded PDFs or other formats. - **Approval steps**: Include review and sign-off in the document workflow. :::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[Integration alternatives] Zapier works for simple connections, but **n8n**, **Make**, or **Microsoft Power Automate** are often more powerful and cost-effective for complex integrations. For full control, consider Tallyfy's [Open API](/products/pro/integrations/open-api/) to build custom integrations. You can even use AI to help write serverless function code. ::: ### Additional form features - **Mobile-friendly**: Forms work on phones and tablets. - **Progress indicators**: Show progress in multi-step forms. - **Default values**: Pre-fill fields with common answers. See [setting default content for form fields](/products/pro/tracking-and-tasks/tasks/how-to-set-default-content-for-form-fields/). - **Clear next steps**: Tell users what happens after submission. - **Testing**: Always test forms with real users before a wide release. - **[Effective operations manuals](https://tallyfy.com/products/pro/tutorials/how-to/build-effective-operations-manual/)**: Tallyfy turns static operations manuals into live digital workflows. Your team tracks and runs procedures in real time instead of letting them gather dust in binders. ## 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 standardizes procedures, preserves company knowledge, and keeps quality consistent. But traditional paper manuals go stale fast, and even when people read them, they [forget 90% within a week](/products/pro/tutorials/why-documentation-training-fails-forgetting-curve/). Tallyfy turns static documents into dynamic, trackable processes using its [operations manual software](https://tallyfy.com/solutions/operations-manual-software/). ### Use digital, device-friendly documentation Paper binders and static PDFs don't work well for modern teams: - **Automatic conversion** - Upload Word docs, PDFs, or other files to Tallyfy. They're converted into web formats accessible on any device. - **Rich media** - Add images, videos, and interactive elements to instructions instead of plain text. - **Access anywhere** - Your team can pull up procedures on any device, anytime. :::tip[Simplifying migration] Start with your core procedures when importing existing documents. Tallyfy's conversion features turn old docs into interactive processes. ::: ### Replace flowcharts with working automations Flowcharts are often complex and hard to follow. Here's a better approach: - **Flowchart conversion** - Upload existing flowcharts to Tallyfy for automatic conversion. - **Simple automation rules** - Replace decision diamonds with "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 conditions. ### Establish ownership and responsibility Every operations manual needs clear owners, both for the overall system and individual procedures: - **System owner** - Appoint one person to oversee all operations documentation. - **Template owners** - Assign 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** - Record who created and last updated each process template. This prevents knowledge from living only in someone's head. ### Organize with a logical hierarchy A clear structure makes procedures easier to find: - **Folder hierarchies** - Group related templates logically using Tallyfy's folders. - **Tagging system** - Use [template tags](/products/pro/documenting/templates/how-to-manage-templates-and-processes-with-tags/) for filtering across categories. - **Naming conventions** - Create consistent naming patterns that identify each template's purpose at a glance. ### Document task information For each procedure, include these details: - **Task definition** - State the task and its purpose clearly. - **Step-by-step instructions** - Detail how to perform each part. - **Role assignments** - Assign responsibility for each step. - **Timing guidance** - Specify when tasks should be done and expected durations. - **Required resources** - List necessary systems, tools, or materials. Tallyfy's [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) and task types capture this information in a structured way. ### Transform documentation into active execution An operations manual only works if people actually follow it. Tallyfy makes that happen: - **Launch processes** - Turn static documents into active work by launching processes from templates. - **Real-time tracking** - See who's completed which steps on Tallyfy's dashboard. - **Automated progression** - Work moves forward automatically as your team completes steps. :::note[Tracking execution metrics] Use Tallyfy's tracking to measure how often procedures are followed. This data helps identify processes that need updates or more training. ::: ### Add clarity with rich media Visuals help people understand and remember procedures better: - **Screenshots** - Show users exactly what they should see at each step. - **Embedded videos** - Demonstrate how to perform tasks. - **Resource links** - Connect to related materials or examples. ### Set up access controls Not everyone should be able 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. ### Measure engagement Analytics show how your operations manual is actually 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 finish successfully. ### Support multilingual operations For teams working across languages: - **Create master templates** - Write 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 automatically apply to translated versions. ### Build in continuous improvement Your operations manual should evolve as your organization does: - **Improvement comments** - Use Tallyfy's [commenting system](/products/pro/tracking-and-tasks/tasks/how-to-report-and-resolve-issues-in-tallyfy/) to collect feedback directly on procedures. - **Regular review cycles** - Schedule periodic reviews with procedure owners. - **Change history** - Keep records of what changed and why. ### Additional practices - **Onboarding integration** - Link the manual to your employee onboarding process. - **Regulatory compliance** - Tag compliance-related procedures for easy auditing. - **Searchable content** - Make sure the manual is easy to search. - **Mobile compatibility** - Test procedures on mobile devices. - **Feedback loops** - Give users a way to suggest improvements. - **[Eliminate tribal knowledge](https://tallyfy.com/products/pro/tutorials/how-to/eliminate-tribal-knowledge-with-workflow-documentation/)**: Tribal knowledge is critical information trapped in employees' heads, creating dangerous single points of failure. Tallyfy converts expert knowledge into step-by-step workflow templates so anyone can follow documented processes without needing an expert present. ## What is tribal knowledge and why does it matter? ![Illustration of tribal knowledge as information trapped in one person while teammates lack access](https://screenshots.tallyfy.com/illustrations/tribal-knowledge.jpeg) Tribal knowledge is critical business information that lives only inside employees' heads. When it's not documented, your organization becomes dangerously dependent on specific people - and that's a risk you can't afford. The [Ebbinghaus forgetting curve](/products/pro/tutorials/why-documentation-training-fails-forgetting-curve/) makes this worse: people forget 90% of what they learn within 7 days. So even when you try transferring tribal knowledge through training, biology works against you. Here's what tribal knowledge looks like in practice: - **Expert mentorship requirements** - new hires must shadow experienced staff multiple times to learn processes - **Single points of failure** - when key people are sick, on vacation, or leave, operations grind to a halt - **Inconsistent execution** - the same process is done differently by different people, causing errors - **Training bottlenecks** - onboarding demands extensive one-on-one time with subject matter experts ### Which industries are hit hardest? Tribal knowledge affects every industry, but some sectors face sharper challenges. #### Insurance and financial services - Complex underwriting with carrier-specific procedures - Regulatory compliance that varies by jurisdiction - Claims processing with multiple conditional pathways - Risk assessment requiring specialized expertise #### Professional services - Client onboarding with industry-specific requirements - Proposal development and project delivery methods - Quality assurance and review processes - Billing 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 audits ### How does tribal knowledge hurt operations? #### Operational risks - **Growth limits** - growth stalls when processes can't be replicated - **Quality gaps** - outcomes vary depending on who does the work - **Knowledge loss** - critical expertise vanishes when employees leave - **Training drag** - new hires need lengthy mentorship periods #### Financial impact - **Higher training costs** - extended onboarding for new employees - **Productivity stalls** - work stops when key people are unavailable - **More errors** - inconsistent execution leads to mistakes and rework - **Wasted time** - hours spent on repetitive training instead of real work ### How Tallyfy eliminates tribal knowledge #### Step 1: Capture the knowledge Turn expert knowledge into structured, repeatable workflows: - **Process documentation** - convert mental models into step-by-step procedures - **Conditional logic** - document decision trees and "if-this-then-that" scenarios - **Context** - include background information and reasoning for each step - **Exception handling** - document how to handle unusual situations and edge cases #### Step 2: Execute consistently Make sure processes run the same way regardless of who's doing the work: - **Guided workflows** - walk users through each step with clear instructions - **Automatic routing** - send tasks to the right team members based on defined rules - **Built-in validation** - add checkpoints and approval steps to maintain quality - **Progress tracking** - monitor completion and spot bottlenecks in real time #### Step 3: Keep improving Refine processes based on real execution data and feedback: - **Performance analytics** - find steps that consistently take longer or cause confusion - **User feedback** - collect improvement suggestions through task comments - **Version control** - update processes while keeping audit trails - **Knowledge sharing** - let teams learn from each other's experiences ### What tribal knowledge challenges does Tallyfy solve? #### 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 an expert hovering nearby - Embedded instructions, videos, and reference materials within each step - Progressive complexity so new hires can start with simpler processes - Built-in checkpoints where supervisors 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 keep execution consistent - Conditional automations that handle variations systematically - Required fields and validations that prevent skipping steps - 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 - not in someone's head - Cross-training through standardized procedures - Multiple people trained on the same documented process - Knowledge retained even when experts leave #### 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 the right steps based on earlier inputs - Progressive information gathering instead of requiring everything upfront - Dynamic workflows that adapt to specific case requirements - Clear decision points with documented criteria for each path ### How to implement knowledge capture #### Phase 1: Identify critical processes Start with the highest-risk areas: - Processes only one or two people can do - Procedures with complex decision trees or many exceptions - Activities that need extensive training periods - Tasks where inconsistency creates quality or compliance problems #### Phase 2: Collaborate with experts Work with subject matter experts to extract their knowledge: - **Interview sessions** - walk through processes step by step with experts - **Process observation** - watch experts work and document their actions - **Exception documentation** - capture how experts handle unusual situations - **Decision criteria** - record the reasoning behind expert judgment calls #### Phase 3: Create Tallyfy templates Turn captured knowledge into executable templates: - **Sequential steps** - break processes into logical, ordered steps - **Assignment rules** - define who should perform each step - **Conditional logic** - implement branching scenarios using [automations](/products/pro/documenting/templates/automations/) - **Supporting materials** - embed reference documents, videos, and resources #### Phase 4: Test and refine Validate your 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** - find missing steps or unclear instructions - **Iterative improvement** - refine templates based on testing feedback ### Best practices for eliminating tribal knowledge #### Start with high-impact, lower-complexity processes - Pick processes that are frequently performed but not overly complex - Focus on procedures that create bottlenecks when experts are unavailable - Prioritize where consistency directly impacts quality or compliance #### Involve multiple subject matter experts - Include different experts who perform the same process to capture variations - Validate procedures with multiple knowledgeable people - Resolve conflicting approaches before finalizing templates #### Include context and reasoning - Document not just *what* to do, but *why* certain steps matter - Explain the business impact of skipping or botching steps - Provide background that helps users make informed decisions #### Plan for exceptions - Document common exceptions and how to handle them - Create escalation procedures for situations not covered in standard workflows - Include contact info for subject matter experts when specialized knowledge is needed #### Keep documentation current - Assign ownership for maintaining processes as requirements change - Set regular review cycles to keep procedures accurate - Build feedback mechanisms so users can suggest improvements from real-world experience - **[Ensure task completion](https://tallyfy.com/products/pro/tutorials/how-to/ensure-task-completion/)**: Tallyfy keeps tasks and approvals on track with automated reminders, clear deadlines, and escalation paths. Built-in comments and @mentions help with direct follow-up. ## Getting tasks and approvals done on time Tallyfy gives you automated reminders, clear task definitions, and escalation paths so tasks and approvals actually get done on time. ### Automated reminders Tallyfy sends task reminders automatically: - **Email digests**: Scheduled reminders go out based on each user's settings. - **Customizable frequency**: Users can adjust how often they're reminded 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 Well-defined tasks are easier to complete. Each task needs: - **Clear purpose**: A specific goal and reason for existing. - **Right scope**: Significant enough to matter, but not overwhelming. - **Definition of done**: Explain what completion actually looks like. - **Reasonable deadlines**: Achievable timelines that allow for quality work. :::tip[Avoiding task fatigue] Don't create too many small, minor tasks. This leads to "approval fatigue" where people start ignoring notifications. Keep tasks meaningful. ::: ### Consolidating related work Group related items to reduce overload and prevent [task debt](/products/pro/tutorials/how-to/how-to-avoid-task-debt/): - **Bundle approvals**: Combine related approvals into one step when possible. - **Use form fields**: A single form with multiple fields beats many separate tasks for collecting information. - **Create logical sequences**: Organize tasks so they flow without repeating work. - **Watch workload balance**: Be mindful of how many tasks you're assigning to each person. - **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. ### Using comments for follow-up Tallyfy's built-in comments let you check task status directly: 1. Open the task. 2. Add a comment. 3. Use \@mentions (e.g., `@username`) to notify specific people. 4. Keep comments focused on the task at hand. Every comment creates an audit trail and notifies assignees right within the task. ### Adding personal communication For critical tasks or ongoing delays, pair digital reminders with personal outreach: - Schedule brief check-in calls to discuss obstacles. - Bring up task status in regular team meetings. - Use chat or instant messaging for quick nudges. - Meet in person (if possible) for high-priority items. ### Explaining why a task matters Include context in task descriptions so people understand the "why": - **State the purpose**: Say clearly why this task matters. - **Connect to goals**: Show how it helps meet team or company objectives. - **Highlight impact**: Explain who benefits when it's done. - **Add background**: Include relevant context if it helps understanding. ### Setting up escalation paths When tasks stay incomplete despite reminders, escalate: - **Reassign to managers**: Use Tallyfy's edit feature to [add the assignee's manager](/products/pro/tracking-and-tasks/tasks/edit-task/how-can-i-assign-members-to-tasks-in-tallyfy/) as a co-assignee. - **\@mention in comments**: Tag managers or senior members to flag the delay. - **Set up automatic escalation**: Pair the step with an [expiring step](/products/pro/tracking-and-tasks/tasks/task-escalation-for-overdue-items/) dated a day or two later, then add an automation that fires when it expires. It can add the manager, change the deadline, reveal a hidden step, or send an alert to another system your team already uses. If the work gets done on time, nothing happens. - **Track patterns**: Log recurring issues to find and fix underlying problems. ### Other helpful strategies - **Recognize on-time completion**: Thank team members who consistently finish tasks on time. - **Track performance**: Use Tallyfy reports to spot patterns and address issues early. - **Simplify the view**: Help people focus by creating custom views of their priority tasks. - **Train your team**: Make sure everyone knows how to use Tallyfy effectively. - **Review processes regularly**: Remove unnecessary tasks that slow things down. - **[Avoiding task debt](https://tallyfy.com/products/pro/tutorials/how-to/how-to-avoid-task-debt/)**: Task debt builds when incomplete tasks pile up faster than your team finishes them. Tallyfy prevents this through expiring tasks, smarter workflow design, and balanced assignment strategies. ## 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 pile up faster than your team finishes them. Like technical debt in software, it compounds, making it harder to focus, creating stress, and killing productivity. The fix isn't working harder. It's designing workflows that prevent buildup in the first place. ### Understanding task debt You keep moving incomplete tasks from one to-do list to the next. Every overdue item starts feeling urgent, making it harder to tell what actually matters. The cascading effect looks like this: - Tracking incomplete work eats mental bandwidth - Team members feel overwhelmed by growing task lists - Overdue items bury important work - People spend more time managing tasks than completing them Task debt doesn't just slow completion rates. It hurts creativity, decision-making, and wellbeing. The longer tasks sit incomplete, the heavier they weigh on your mind. ### Using expiring tasks for information sharing The most effective way to prevent task debt? [Expiring tasks](/products/pro/tracking-and-tasks/tasks/what-types-of-tasks-can-i-create-with-tallyfy/) - a Tallyfy feature that auto-completes tasks at their deadline if nobody finishes them first. Think Mission Impossible: "This message will self-destruct in 5 seconds." If nobody acts by the deadline, the task completes itself. Expiring tasks are perfect for sharing information that's helpful but not critical: - Weekly updates team members can review if they have time - FYI notifications that don't require action - Optional training materials or resources - Status reports that are informative but not mandatory The key insight: expiring tasks let you share information without creating debt. Team members get notified and can engage if they want, but the task won't sit there forever. At the deadline, it marks itself complete and disappears from the overdue list. ### Strategic task design You can also prevent task debt through smarter workflow design: **Bundle related work.** Instead of creating ten separate approval tasks, combine them into one review task with multiple [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/). Fewer items means less psychological burden. **Set realistic deadlines.** Tasks with impossibly short deadlines immediately become overdue. Build buffer time based on actual completion patterns, not optimistic estimates. **Eliminate low-value tasks.** Audit your [templates](/products/pro/documenting/templates/) regularly. If a task consistently gets skipped 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 directly affects debt accumulation: **Balance workloads.** Before assigning tasks, check what people already have. Tallyfy's [tracker view](/products/pro/tracking-and-tasks/tracker-view/) shows who has what on their plate. Distribute work evenly instead of overloading specific people. **Use job title assignments.** Assign to [job titles](/products/pro/documenting/templates/edit-templates/understanding-assignment-types/) rather than specific people for routine tasks. This distributes work automatically and prevents bottlenecks when someone's unavailable. **Group assignments with Take Over.** For tasks that need one person from a group, assign to the group and let someone claim ownership via Take Over. This stops tasks from sitting unowned while everyone assumes someone else will handle it. ### Managing existing task debt Already drowning in task debt? Here's how to dig out: 1. **Apply the two-minute rule.** Scan your overdue tasks. Anything that takes less than two minutes, do it now. This quickly shrinks the visible backlog. 2. **Batch similar tasks.** Group related overdue items and handle them together. Processing ten expense reports at once beats doing them one at a time. 3. **Convert to expiring tasks.** Informational items that keep getting pushed? Make them expiring. They'll auto-complete at deadline, clearing your backlog. 4. **Cut ruthlessly.** Some tasks simply won't get done. Cancel them. Document why if needed, then move on. 5. **Renegotiate deadlines.** For tasks that matter but can't happen immediately, set new realistic deadlines. This removes them from the overdue list while keeping accountability. ### Creating sustainable workflows Preventing task debt long-term means building sustainability into your workflows: **Regular reviews.** Schedule monthly reviews of task completion rates. If certain tasks consistently go overdue, eliminate them, extend deadlines, or convert them to expiring tasks. **Feedback loops.** Encourage team members to flag tasks that don't add value. They're closest to the work and can spot unnecessary steps. **Process metrics.** Use [Tallyfy Analytics](/products/pro/integrations/analytics/) to track completion patterns. Look for bottlenecks and recurring delays, then fix root causes, not 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. ### Setting up expiring tasks Here's how to create expiring tasks in Tallyfy: 1. Go 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 4. Write clear descriptions explaining this is optional or informational 5. Use descriptive names like "FYI: Weekly metrics update" or "Optional: Training video available" Expiring tasks still trigger notifications, so assignees know information is available. They just don't create permanent debt if ignored. - **[Merge templates](https://tallyfy.com/products/pro/tutorials/how-to/how-to-merge-two-process-templates/)**: Merge two Tallyfy procedure templates by exporting both as documents and using an AI tool to combine all steps and details. Then import the result back into Tallyfy as a new template. Tallyfy doesn't have a built-in feature to merge two [procedure templates](/products/pro/documenting/templates/) into one. But you can work around this by exporting both templates as documents, using an AI tool to combine them, and importing the result back into Tallyfy. ## Prerequisites - Two existing [procedure templates](/products/pro/documenting/templates/) in Tallyfy that you want to merge. - Access to an AI tool (e.g., ChatGPT, Google Gemini, Claude). - A way to convert the AI tool's output into a Word (`.docx`) or PDF (`.pdf`) file. ## Steps to merge two templates :::note[Review and refine] After importing, review the new template carefully. You may need to adjust steps, formatting, assignments, or add [automations](/products/pro/documenting/templates/automations/) - Tallyfy's AI interpretation of the uploaded document might not be perfect. ::: - **[Improve processes effectively](https://tallyfy.com/products/pro/tutorials/how-to/improve-processes-effectively/)**: Tallyfy enables ongoing process improvement by letting teams capture feedback directly on tasks and using analytics to spot bottlenecks. Template updates deploy instantly without version management or downtime. ## 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 The people doing daily tasks are your best source of improvement ideas: - **Improvement comments**: Use Tallyfy's [built-in comments](/products/pro/tracking-and-tasks/tasks/how-to-report-and-resolve-issues-in-tallyfy/) to capture ideas directly within specific process steps. - **Structured feedback**: Add feedback steps at the end of [processes](/products/pro/tracking-and-tasks/processes/) to collect suggestions regularly. - **Anonymous submissions**: Allow anonymous feedback for more honest input. - **Idea voting**: Let team members upvote the suggestions they find most useful. :::tip[Using contextual feedback] Tallyfy's comments let team members suggest improvements directly on specific tasks. This gives you context on exactly where and how a process can be improved - far better than generic feedback forms. ::: ### 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. Focus on root causes, not symptoms. Late deliveries, for example, might signal issues in scheduling or fulfillment processes - not just shipping. ### Find bottlenecks with analytics - **Process duration analysis**: Use Tallyfy [Analytics](/products/pro/integrations/analytics/) to spot which steps take longer than planned. - **Bottleneck identification**: Find steps where work regularly 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 causing delays. ### Communicate why you're changing things - **State the problem**: Define the issue the process change is meant to fix. - **Explain the impact**: Show how the current process affects customers, team members, or results. - **Share the vision**: Describe what the improved process will look like. - **Connect to values**: Link the change to company values or strategic goals. :::note[Change management basics] Consider methods like Kotter's 8-Step Model or ADKAR (Awareness, Desire, Knowledge, Ability, Reinforcement). Structured approaches like these increase your chances of successful adoption. ::: ### Deploy changes instantly Tallyfy's template system makes rolling out improvements simple: - **Instant updates**: Changes to [templates](/products/pro/documenting/templates/) apply immediately - no complex versioning needed. - **Automatic rollout**: The next process launched automatically uses the newest template version. - **No update windows**: Make small changes anytime without scheduling downtime. - **No version sprawl**: You won't need to manage multiple 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**: Treat each small change as a learning opportunity for future improvements. ### 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. For any process step, ask these three questions in order: 1. Can we eliminate this step entirely? 2. If not, can we automate it? 3. If people must do it, how do we make it faster and less error-prone? :::tip[Identifying automation candidates] Steps that are good candidates for full automation typically: - Follow clear rules with specific criteria - Happen frequently or in large volumes - Are repetitive with little variation - Don't require much judgment - Use structured data with clear inputs and outputs ::: ### Measure customer impact - **Customer journey mapping**: See how process changes affect the overall customer experience. - **Outcome metrics**: Track customer-focused numbers like satisfaction, retention, or referrals. - **Value stream analysis**: Check whether changes affect activities that create real customer value. - **Customer feedback loops**: Ask customers directly about the impact of process changes. ### Structured improvement methods - **Lean**: Remove wasted effort and maximize value delivery. - **Six Sigma**: Reduce variation and errors using data analysis. - **Kaizen**: Make small, ongoing improvements continuously. - **PDCA (Plan-Do-Check-Act)**: Test changes in small batches before full rollout. Most organizations mix elements from different methods - and that's fine. ### Document what you changed - **Update Tallyfy templates**: Make sure templates reflect the improved processes. - **Record lessons learned**: Write down what worked, what didn't, and why. - **Share success stories**: Tell others in your company about improvements and their results. - **Create reusable patterns**: Identify successful approaches that could work for other processes. ### Balance standardization with flexibility - **Standardize the core**: Keep the main parts of a process standard for quality and compliance. - **Allow contextual variation**: Give teams flexibility to adapt to unique situations. - **Define decision boundaries**: Clarify where judgment is okay and where standards must be followed. - **Review exceptions**: Monitor when standard processes get bypassed - that's often where improvement opportunities hide. ### Additional improvement strategies - **Process mining**: Use tools to discover how processes actually run based on system data. - **Cross-functional input**: Get perspectives from different roles when designing improvements. - **Pilot testing**: Test big changes on a small scale before full rollout. - **Regular review cycles**: Schedule process reviews instead of waiting for problems to surface. - **Training**: Make sure teams understand and can perform improved processes. - **Recognition**: Acknowledge team members who suggest good improvements. - **[Import a Word document](https://tallyfy.com/products/pro/tutorials/how-to/import-a-word-document/)**: Convert any Word document describing a process into a live, runnable Tallyfy template. Works with documents generated by Process Documentation AI (tallyfy.com/tools/process-documentation-ai/) or any Word file with sections and numbered steps. You can turn any Word document that describes a process into a runnable Tallyfy template. Tallyfy's AI reads your document, identifies sections and steps, and creates a [procedure template](/products/pro/documenting/templates/) you can launch and track. ## When to use this - You generated a procedure with the free [Process Documentation AI tool](https://tallyfy.com/tools/process-documentation-ai/) at `tallyfy.com/tools/process-documentation-ai/` and want to run it for real. - You already have an SOP, runbook, or process manual in Word format and want to stop running it manually. - A consultant or colleague sent you a `.docx` describing how to do something. ## Prerequisites - A free Tallyfy account. [Sign up at tallyfy.com/start](https://tallyfy.com/start) if you do not have one. - A Word document (`.docx`) describing the process. The document should have: - A clear title. - Section or chapter headings that group related steps. - Numbered or bulleted steps that describe what to do. - Optional but helpful: role assignments per step, deadlines, automation ideas. The structure produced by [Process Documentation AI](https://tallyfy.com/tools/process-documentation-ai/) is ideal because it already includes role assignments, deadline guidance, and a Tallyfy-specific automation section. ## Steps to import ## Tips for best results - **Keep the document focused on one process.** Documents that mix multiple processes confuse the AI and produce worse drafts. - **Use clear section headings.** Sections become natural groupings in the resulting Tallyfy template. - **Mention role names.** Phrases like "the IT Operations team..." or "the Hiring Manager will..." help the AI suggest correct assignees. - **Describe automations as a separate section.** If your document ends with a list of "if X happens, do Y" rules, Tallyfy can use those as a guide when you set up [automation rules](/products/pro/documenting/templates/automations/) for the template. ## Where the Process Documentation AI tool fits The free [Process Documentation AI tool](https://tallyfy.com/tools/process-documentation-ai/) writes a `.docx` specifically shaped for this import flow. It produces: - A clear title and a 2-sentence intro - Sections with numbered steps - A suggested role for every step - Deadline guidance per step - A Tallyfy automation section at the end with concrete rule suggestions You do not need an account to use the tool. Once you have the document, sign up for free and follow the steps above to bring it into Tallyfy. - **[Improve accountability](https://tallyfy.com/products/pro/tutorials/how-to/make-people-accountable-for-tasks/)**: Tallyfy makes task accountability clear through transparent dashboards, automatic reminders, and single-person ownership via Take Over. Blocker documentation, escalation paths, and expiring tasks prevent backlog buildup. ## 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 gives you built-in tools to make task accountability clear, visible, and lasting, without micromanaging anyone. ### Transparent workflows When everyone can see task status, accountability happens naturally: - **Public task status**: Tallyfy's dashboard shows who's responsible for each active task and its current status. - **Progress tracking**: Visual indicators highlight where processes are stuck and who owns the bottleneck. - **Timeline views**: History shows when tasks were assigned, started, and completed. - **Activity logs**: Tallyfy automatically records all actions taken on tasks. ### Automatic reminders Set up reminders once and they'll keep working across every task: - **Daily digest emails**: Personalized notifications about pending tasks go out automatically. - **Customizable frequency**: Users set their preferred [reminder schedule](/products/pro/settings/personal-settings/how-can-i-manage-email-notifications-in-tallyfy/). - **Set-and-forget**: No manual follow-up needed once configured. - **Overdue highlighting**: Reminders flag overdue tasks and approaching deadlines. ### Manual reminders for urgent tasks For time-sensitive work, you can send 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 messages**: Add personal notes to stress urgency or provide context. - **Sequential escalation**: Follow a consistent pattern - reminder, then direct message, then manager involvement. Save manual nudges for genuinely urgent situations. ### Single-person ownership with "Take Over" When multiple people are assigned, nobody owns the task. The Take Over feature fixes that: - **One-click ownership**: Tallyfy lets a team member claim full ownership of a task. - **Clear assignment**: When someone takes over, others are removed. No ambiguity. - **Voluntary commitment**: Choosing to take over creates personal accountability. - **Documented handoffs**: The system logs who took responsibility and when. :::note[When to use the 'Take Over' feature] Take Over works best 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. ::: ### Comments for accountability Task-level comments keep accountability discussions focused: - **Contextual questions**: Ask about task status directly in the task's comments. - **@mentions**: Tag specific people to make sure they see your message. - **Default comments**: Use standard comment templates for consistent check-ins. - **Email notifications**: Comments automatically trigger email alerts to assignees. ### Documenting blockers When tasks are blocked, making that visible matters: - **Blocking comments**: Team members can mark comments as blockers, showing exactly what's stopping progress. - **Blocker visibility**: These comments display prominently, explaining why a task is delayed. - **Shared problem-solving**: Transparency helps teams work together on solutions. - **Accountability transfer**: Responsibility shifts from the blocked person to whoever can fix the blocker. This distinction between avoidance and genuine blockers matters. ### Clear task instructions Better instructions mean fewer excuses for incomplete work: - **Step-by-step guidance**: Include specific instructions in every task. - **Defined success criteria**: Explain what "done" looks like. - **Resource links**: Provide links to needed info, tools, or templates. - **Supporting materials**: Attach examples or training documents. ### Task expiration policies Configure tasks to auto-complete after deadlines. This prevents [task debt](/products/pro/tutorials/how-to/how-to-avoid-task-debt/): - **Expiring task types**: Set certain tasks to auto-complete after their deadline. Perfect for FYI items. - **Time-based auto-completion**: Create rules for tasks to close automatically after a set period. - **Clear expectations**: Tell your team about these policies so they understand the consequences of inaction. - **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 or optional content without creating permanent backlog. ### Escalation paths Structure your escalation so it's consistent and fair: - **Sequential escalation**: Follow a pattern - reminder, then comment, then manager added. - **Manager involvement**: Add supervisors as assignees if earlier steps don't work. - **Pattern recognition**: Track recurring issues to find and fix root causes. - **Performance connections**: Connect consistent task completion (or lack of it) to performance reviews. ### Balanced accountability culture Accountability works best when paired with support: - **Recognition**: Acknowledge people who consistently complete tasks on time. - **Constructive approach**: Focus conversations on solving problems, not assigning blame. - **Skill development**: Offer training for those struggling with tasks. - **Reciprocal accountability**: Hold managers responsible for providing support and removing obstacles. ### Additional strategies - **Start with why**: Explain the task's purpose and impact. - **Manage workloads**: Make sure task loads are reasonable. - **Time blocking**: Encourage scheduling dedicated time for Tallyfy tasks. - **Peer partnerships**: Set up ways for teammates to check in on each other. - **Break down big tasks**: Divide large responsibilities into smaller, trackable tasks. - **[Complex approval workflows](https://tallyfy.com/products/pro/tutorials/how-to/track-and-run-complex-approval-workflows/)**: Tallyfy turns multi-level approval processes into visible, trackable workflows. Use kick-off forms, conditional logic, and automated reminders to route tasks to the right approvers and eliminate bottlenecks. ## Turn multi-level approvals into trackable processes Complex approvals slow things down when people can't see the status, requirements, or next steps. Tallyfy turns these into trackable workflows with clear visibility and accountability. ### Design kick-off forms Start with the right information upfront: - **Identify required data** - determine what's needed before approval can begin. - **Build a concise kick-off form** - include only [essential fields](/products/pro/tutorials/how-to/build-effective-forms/) so it's easy to submit. - **Pick the right field types** - use appropriate [form field types](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) (dropdowns, file uploads, etc.). - **Add field guidance** - explain what info is needed and why. - **Set validation rules** - use [field validation](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/#short-text-field) to catch bad data early. :::tip[Auto-creating from existing documents] If your approval workflow already exists in a document, Tallyfy can convert it into a template automatically. Upload the document and it'll try to extract steps. ::: ### Break down approval steps Divide approvals into distinct steps: - **Map the full process** - list every step from start to finish. - **Define the sequence** - set which approvals come first. - **Identify decision-makers** - decide who approves or gives input at each stage. - **Include policy requirements** - add company policies to step instructions. - **Plan parallel vs. sequential** - decide which steps can run 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 Here's how a typical purchase approval flows through decision points and assignments. [Diagram removed for brevity] **What to notice:** - High-value purchases (over $10,000) automatically route to CFO approval for financial oversight - Reviews go to specialists based on purchase category - software triggers a privacy review, hardware goes to IT, services go to procurement - Invalid data loops back to the submitter for correction (shown with dashed lines) ### Set up conditional visibility Not every step applies in every situation. Use rules to show only what's relevant: - **Identify decision points** - find where the process splits 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 or hide steps. - **Build dynamic approval paths** - approvers only see tasks that apply to them. For example: ``` IF (Purchase Amount) is greater than $10,000 THEN SHOW "CFO Approval" ``` This way, people only see tasks relevant to their specific approval. ### Configure dynamic assignments Automatically route tasks to the right approvers: - **Define role-based assignments** - decide which roles handle each step. - **Use variable assignments** - use [assignment actions](/products/pro/documenting/templates/automations/actions/asignment-actions/) to assign tasks based on form answers. - **Add conditional routing** - send approvals to different people based on department, amount, or category. - **Set up backups** - assign to groups or multiple people to cover absences. For example: ``` IF (Purchase Category) is "Software" THEN assign "Vendor Privacy Review" to "Jane Doe" ``` This sends requests to the right experts without manual routing. ### Track approval status in real time - **Central 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/). - **Live status updates** - see which step is active and who's responsible. - **Deadline monitoring** - track upcoming and overdue approvals with color coding. - **Progress visualization** - view completion percentage and remaining steps. - **Activity logs** - access [history](/products/pro/tracking-and-tasks/tracker-view/how-can-i-track-process-activities-on-tallyfy/) showing every action taken. No more "where is my approval?" questions. ### 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 paths** - 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/). - **Manual reminders** - process owners can 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. Approvals won't get stuck because of missed emails or busy schedules. ### Enable workflow communication Approvals often need extra info or discussion. Tallyfy's comments keep this organized: - **Step-specific comments** - ask questions or give feedback directly on approval steps. - **@mentions** - tag people in comments to get their attention. - **Embedded context** - no need to re-explain the situation with every question. - **Conditional approvals** - respond with "Approved if you provide X" instead of just yes/no. - **Comment history** - keeps a full record of discussions for audit purposes. ### Organize and archive approvals Keep records organized and easy to find: - **Tagging** - have submitters [tag or categorize](/products/pro/documenting/templates/how-to-manage-templates-and-processes-with-tags/) requests. - **Folder organization** - file completed approvals into the right [folders](/products/pro/tracking-and-tasks/tracker-view/organize-processes/). - **Searchable archives** - find past approvals using search and filters. - **Data export** - [export approval data](/products/pro/tracking-and-tasks/processes/how-can-i-export-tallyfy-processes-to-csv/) for reporting. - **Retention policies** - set up archiving based on company rules. Completed approvals stay accessible for audits while keeping active views clean. ### Best practices - **Start simple** - begin with core steps and add complexity only as needed. - **Involve approvers early** - get their input when designing the workflow. - **Test small** - run pilot approvals before rolling out broadly. - **Document criteria** - create clear guidelines for approval decisions. - **Review regularly** - analyze completed approvals to find bottlenecks and improvements. - **Track metrics** - measure approval time, rejection rates, and delays. Tallyfy treats approvals as collaborative human processes, not just requests being routed around. [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/)**: Track actual work effort by adding hours and minutes fields to Tallyfy tasks. Direct time input gives cleaner data than elapsed-time timestamps, which are often skewed by holidays and external delays. ## How to track time in Tallyfy You can track time by adding number fields to tasks with validation rules. This captures hours and minutes spent on each task - useful for cost analysis and workflow measurement. ### Prerequisites - Administrator or Standard user role - Access to edit [templates](/products/pro/documenting/templates/) - Familiarity with [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 measuring task efficiency - Compliance requirements mandating time documentation - Resource planning based on actual task duration ## Steps to set up time tracking ## Advanced configurations ### Using variables to display time Tallyfy doesn't auto-calculate totals, but you can use [variables](/products/pro/documenting/templates/variables/) to show entered time in later tasks: 1. In a later task's description, insert: `{{Hours spent on this task}} hours and {{Minutes spent on this task}} minutes were logged` 2. This gives approvers or reviewers visibility into time spent ### Time-based automations Use [automation rules](/products/pro/documenting/templates/automations/) to trigger actions based on time entries: - If hours spent > 8, assign a task to a manager for review - If total time exceeds budget, send a notification email ### Project-wide time tracking To track time across an entire process: 1. Add time fields to every task that needs measurement 2. Create a summary task at the end titled "Time Tracking Summary" 3. List all time variables from previous tasks in the description 4. Export data via [CSV](/products/pro/tracking-and-tasks/processes/how-can-i-export-tallyfy-processes-to-csv/) for analysis ## Why accurate time tracking is hard ### Multi-tasking makes tracking difficult People rarely work on one task at a time. Someone might spend 30 minutes on a task, get pulled into a meeting, answer emails, then finish an hour later. Did that take 30 minutes or 90? Both answers have merit. ### Holidays and absences skew averages 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 Waiting for client feedback, dependencies on delayed tasks, or system outages all add time that has nothing to do with actual work effort. ### The fix: ask for time input directly Add a form field asking assignees to record their actual working time. It's one more field to fill out - but it gives you clean data about real effort. Why this works: - People know how much time they actually spent (not elapsed time) - External delays don't contaminate your data - You can still track elapsed time through Tallyfy's built-in timestamps ### Analytics timestamps have the same challenges Timestamps in Tallyfy Analytics and CSV exports measure elapsed time between task assignment and completion. They're subject to all the issues above. That "3-day average" might represent 30 minutes of work spread across a long weekend. Use effort tracking fields for cleaner metrics. ## Best practices ### Field naming conventions Use consistent naming for easier reporting: - "Task Name - Hours" - "Task Name - Minutes" ### Setting realistic limits - Set maximum hours based on typical task duration - Use validation to prevent data entry errors - Consider dropdown lists for standard time increments ### Training your team - Add guidance text explaining time tracking expectations - Specify whether to track active work time or total elapsed time - Explain the difference between effort time and elapsed time ### Regular analysis - Export process data monthly to spot time trends - Identify tasks consistently taking longer than expected - Consider both effort metrics and elapsed time when analyzing bottlenecks ## Common scenarios ### Billable hours tracking For client billing, consider adding: - A "Billable?" radio button field (Yes/No) - A "Billing Code" dropdown field - Separate fields for billable vs non-billable time ### Compliance time logs For regulatory requirements: - Make all time fields required - Include fields for start time, end time, break duration, and delay reasons ### Performance metrics To measure efficiency: - Track both estimated and actual time - Add "Estimated Hours" and "Estimated Minutes" fields - 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 or 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 **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 a "Time Entry Method" field with options like "Timer", "Estimate", "Calculated" - **[Use Tallyfy as a lightweight CRM](https://tallyfy.com/products/pro/tutorials/how-to/use-tallyfy-as-lightweight-crm/)**: Tallyfy works as a simple sales pipeline tracker for small teams. Turn template steps into deal stages, capture lead data with kick-off forms, and monitor up to 50 active deals in tracker view. ## Tracking a sales pipeline with Tallyfy Tallyfy works as a lightweight CRM for small teams with simple sales processes. Create a template where each step is a pipeline stage, capture lead data with kick-off form fields, and monitor deals through tracker view. It's best for fewer than 50 active deals. For persistent contact records or revenue forecasting, pair Tallyfy with a [dedicated CRM](/products/pro/integrations/middleware/integrate-into-crm/). ## Managing and reporting Launch a process per new lead, then use [tracker view](/products/pro/tracking-and-tasks/tracker-view/) to monitor your pipeline. Board view shows columns per stage. Table view shows all deals with form data as sortable columns. - **CSV export** from tracker view for Excel/Sheets analysis - **Tallyfy Analytics** copies data to Amazon Athena for BI tools - see [analytics](/products/pro/integrations/analytics/) - **Time tracking** via number fields on tasks - see [track time](/products/pro/tutorials/how-to/track-time-in-tasks/) Tallyfy isn't a full CRM - you won't get persistent contact records, revenue forecasting, or email tracking. When you outgrow this approach, connect to Salesforce or HubSpot via [middleware](/products/pro/integrations/middleware/). - **[Process improvement](https://tallyfy.com/products/pro/tutorials/how-to/process-improvement/)**: A guide to process improvement covering core concepts and methods like DMAIC, Lean, and Kaizen. Shows how Tallyfy's documentation, automation, and analytics help teams identify waste, fix root causes, and build a culture of continuous improvement. ## How can I understand core concepts of process improvement? Better business processes mean higher efficiency, happier customers, and a stronger competitive position. For a broader perspective, see our guide on [continuous process improvement](https://tallyfy.com/continuous-process-improvement/). This guide covers process improvement from foundational concepts to specific methods - all tailored to how you can use Tallyfy. We'll focus especially on how these principles, often rooted in manufacturing, apply to office environments and professional services. Tallyfy lets you document, manage, and automate your processes - creating the right conditions for continuous improvement. ## What's covered in this guide? These articles walk you through understanding and implementing process improvement with Tallyfy: - Fundamentals of process improvement and its benefits - Understanding and documenting your current processes with Tallyfy - Identifying what customers truly value (Critical to Quality requirements) - Improvement methods like DMAIC, Lean (waste elimination), and Kaizen (continuous small improvements) applied to office settings - Gathering data, analyzing root causes, and generating effective solutions - Using Tallyfy features like contextual comments, AI suggestions, and real-time analytics to speed up improvement - Simplifying change management and building a lasting culture of continuous improvement ### Process improvement - **[Build a culture of continuous improvement](https://tallyfy.com/products/pro/tutorials/how-to/process-improvement/building-a-culture-of-continuous-improvement/)**: A continuous improvement culture means everyone actively identifies process improvements daily. Tallyfy supports this with visible templates, in-task feedback, analytics, and instant updates for rapid experimentation. ## How do you build a continuous improvement culture? A **culture of continuous improvement (CI)** is a mindset where everyone in your organization actively looks for ways to make processes better - every day, not just during occasional projects. Tallyfy helps you build and sustain this culture by making processes visible, trackable, and easy to change. ### What defines a CI culture? In a CI culture, improvement isn't a one-off initiative - it's part of how daily work gets done. Here's what that looks like: - **Leadership commitment** - Leaders champion CI, model the right behaviors, and remove barriers to improvement. - **Employee involvement** - Everyone, especially those closest to the work, feels responsible for suggesting and making improvements. - **Open communication** - Ideas and constructive criticism are welcomed and discussed openly. - **Learning from experience** - Both successes and mistakes become learning opportunities, recognizing that traditional training [fails due to memory limitations](/products/pro/tutorials/why-documentation-training-fails-forgetting-curve/). - **Celebrating progress** - Recognizing 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 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 does a CI culture matter? Organizations that build a strong CI culture see long-term benefits: - **Sustained results** - Improvements stick and compound over time. - **Greater adaptability** - The organization becomes more agile and responsive to changing customer needs. - **Higher employee engagement** - When people have a voice and see their ideas making a difference, motivation and job satisfaction increase. - **More innovation** - A culture that encourages questioning and experimentation naturally produces new ideas. ### How does Tallyfy support a CI culture? Tallyfy isn't just a process execution tool. Its features directly support a continuous improvement mindset: 1. **Bottom-up suggestions through comments** - Tallyfy's [in-task comment feature](/products/pro/tracking-and-tasks/tasks/how-to-report-and-resolve-issues-in-tallyfy/) gives anyone running a process a direct channel to flag issues or suggest improvements right when they notice them. Frontline insights don't get lost. 2. **Transparency and shared understanding** - With [Tallyfy templates](/products/pro/documenting/templates/), processes aren't hidden in manuals or someone's head. They're visible to all relevant team members, so everyone sees how work gets done and where improvements are possible. 3. **Stable baselines with standardized templates** - CI requires a stable starting point. Tallyfy templates act as your standardized processes - everyone works from the same playbook, making it easier to spot deviations and measure the impact of changes. 4. **Data-driven decisions with analytics** - [Tallyfy Analytics](/products/pro/integrations/analytics/) gives you objective data on process performance, so teams can identify improvement areas based on facts rather than assumptions. 5. **Rapid iteration and learning** - Tallyfy [templates can be updated](/products/pro/documenting/templates/edit-templates/) and changes deployed instantly. This fast iteration cycle lets teams test small improvements and learn quickly. 6. **Low barrier to process ownership** - Tallyfy's simplicity means teams can easily document and own their processes. This local ownership drives CI - the people closest to the work are best positioned to improve it. :::tip[Leadership role in a Tallyfy-powered CI culture] Leaders can actively support this culture by: - Regularly reviewing improvement suggestions in Tallyfy comments. - Using Tallyfy to track and showcase improvement initiatives. - Publicly recognizing individuals and teams who contribute process improvements. - Encouraging experimentation, even when some changes don't produce the expected results right away. ::: - **[Gather data and use Tallyfy Analytics](https://tallyfy.com/products/pro/tutorials/how-to/process-improvement/gathering-data-and-using-tallyfy-analytics-for-insights/)**: Good process improvement runs on real data, not assumptions. Tallyfy Analytics captures task completion times and bottleneck patterns that you can connect to BI tools like Tableau or Power BI for spotting trends. ## Use data and analytics to guide improvements Good process improvement runs on facts, not guesswork. Data shows you how processes actually perform, where real problems exist, and whether changes make a difference. ### Why data is essential - **Manages by fact**: Data replaces assumptions with objective evidence. - **Identifies real problems**: Helps distinguish symptoms from root causes. - **Baselines performance**: You need to know where you are to measure progress. - **Pinpoints bottlenecks**: Shows where work gets stuck or takes too long. - **Measures impact**: Validates whether changes had the desired effect. ### What data should you collect? Align your data collection with **Critical to Quality (CTQ)** requirements - what your customers value - and overall process performance. There are two main types: - **Output measures (Y variables)**: Results and outcomes of your process. - Customer satisfaction scores (e.g., NPS, CSAT) - Error rates or defect counts (e.g., incorrect invoices) - On-time delivery percentage - Total process completion time (cycle time) - **Process measures (X variables)**: In-process metrics that influence outputs. - 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** helps - even a basic checklist answering: What to collect? Why? How? When/how often? Where in the process? Who's responsible? ### How Tallyfy helps gather process data Manual data collection is time-consuming and error-prone. **[Tallyfy Analytics](/products/pro/integrations/analytics/)** is an add-on service where you connect your own BI tools to analyze workflow data that Tallyfy captures automatically, including: - **Task completion times**: How long each step 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**: Total end-to-end time for each process instance. - **User workload and performance**: How tasks are distributed and completed across team members. - **Overdue tasks**: Tasks and processes falling behind schedule. - **Step-by-step bottlenecks**: Where work consistently slows down. ### Using Tallyfy Analytics to find improvement opportunities Regularly reviewing data from [Tallyfy Analytics](/products/pro/integrations/analytics/) in your BI tools reveals where to focus: - **Identify bottlenecks**: Spot steps that consistently take longer than others. Why is this step slow? Can it be simplified, resourced differently, or automated? - **Track cycle times**: Monitor average completion time for entire processes. Increasing or highly variable cycle times signal a need for improvement. - **Monitor on-time completion**: Check if processes and tasks meet their deadlines. High overdue rates point to workload, complexity, or unrealistic deadline issues. - **Understand workload distribution**: Find team members who are consistently overloaded - this leads to delays and burnout. Consider reassigning tasks or redesigning parts of the process. :::tip[Stay ahead with analytics] Don't wait for problems to become critical. Schedule regular reviews (e.g., weekly or monthly) to catch emerging issues early. ::: ### Visualizing data for clearer insights Raw numbers are hard to interpret. Charts and graphs make trends, patterns, and outliers clear. Tallyfy Analytics lets you connect BI tools like Tableau, Power BI, or Looker for custom visualizations. Two useful chart types: - **Run charts**: Plot a metric (like task completion time) over time to reveal trends or seasonal patterns. - **Pareto charts**: Identify the "vital few" causes of a problem (e.g., the 20% of error types causing 80% of rework). When Tallyfy data shows tasks frequently stuck at one step, or comments indicating confusion there, that's a clear signal. The process likely needs simpler instructions, extra resources, or a redesign. You can also export process data for more advanced analysis if your needs are very specific, but for most day-to-day process improvement, it's a strong starting point. - **[Generate, test, and prioritize improvement ideas](https://tallyfy.com/products/pro/tutorials/how-to/process-improvement/generating-testing-and-prioritizing-improvement-ideas/)**: Use structured brainstorming techniques like SCAMPER and brainwriting to generate process improvement ideas. Test them through small-scale pilots, then prioritize with an impact/effort matrix to focus on high-value changes. ## How do you move from ideas to real improvements? After you've analyzed your process and found root causes (covered in [Simple root cause analysis techniques](/products/pro/tutorials/how-to/process-improvement/simple-root-cause-analysis-techniques/)), it's time to generate, test, and prioritize potential solutions. Creativity meets practicality here. ### How can you generate improvement ideas? Don't settle for the first solution that comes to mind. Push for a wide range of ideas - even unconventional ones. - **Brainstorming**: A group freely generates ideas without initial criticism. Aim for volume. Variations include: - *Negative brainstorming*: Ask, "How could we make this process even worse?" Then flip those answers into positive solutions. - *Brainwriting*: Everyone writes ideas individually before sharing, so quieter voices get heard. - **SCAMPER**: This acronym drives 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 ideas does it suggest? - **M**odify: Can you change an attribute - size, shape, or frequency? - **P**ut to other uses: Can the process or parts of it serve a different purpose? - **E**liminate: What can be removed or simplified? - **R**earrange/Reverse: Can you change step order or reverse the flow? **Tallyfy for idea generation:** - Create a dedicated [Tallyfy template](/products/pro/documenting/templates/) for brainstorming. Each step becomes a creative prompt, with team members adding ideas via [task comments](/products/pro/tracking-and-tasks/tasks/how-to-report-and-resolve-issues-in-tallyfy/) or [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/). - Don't overlook existing Tallyfy comments on operational processes - they're often a goldmine of improvement suggestions from the people doing the work. ### How can you test ideas through piloting? Test improvements on a small scale before committing to a full rollout. That's piloting. - **Why pilot?** It reduces risk, gathers real-world feedback, validates assumptions, and refines the solution before wider rollout. - **Running a simple pilot in Tallyfy**: 1. Copy the existing Tallyfy template. 2. Modify the copy with your proposed improvement. 3. Assign the pilot template to a small, representative group of users or a limited number of cases/time period. 4. Define what you'll measure to judge success (e.g., time reduction, error rate, user feedback). [Tallyfy Analytics](/products/pro/integrations/analytics/) on the pilot template gives you quantitative performance data, while [task comments](/products/pro/tracking-and-tasks/tasks/how-to-report-and-resolve-issues-in-tallyfy/) capture qualitative feedback from pilot users. ### How do you prioritize improvement ideas? You'll often generate more good ideas than you can tackle at once. Prioritization keeps your effort focused on the highest-value changes. - **Impact/effort matrix**: This 2x2 grid categorizes ideas by potential impact (high/low) and effort to implement (high/low). - **High impact, low effort (quick wins)**: Tackle these first. - **High impact, high effort (major projects)**: Plan and resource these carefully. - **Low impact, low effort (fill-ins)**: Bundle them or fit them in when time allows. - **Low impact, high effort (time sinks)**: Skip these unless there's a strong strategic reason. - **Criteria selection matrix**: For more formal prioritization, score each solution against criteria like cost, time to implement, customer satisfaction gain, and strategic alignment. Weight each criterion by importance. **Tallyfy for prioritization:** Discuss ideas captured in Tallyfy [comments](/products/pro/tracking-and-tasks/tasks/how-to-report-and-resolve-issues-in-tallyfy/) collaboratively. [Tallyfy Analytics](/products/pro/integrations/analytics/) can inform impact estimates (e.g., "this step takes 50% of the process time, so improving it would be high impact"). Judge effort by how easy the [Tallyfy template](/products/pro/documenting/templates/) is to modify. - **[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 accelerates process improvement beyond traditional workshops and suggestion boxes by letting team members comment directly on specific process steps to capture real-time feedback and by using AI to draft templates from plain language or legacy documents while also surfacing data-driven improvement suggestions that deploy instantly across all new process launches. ## How can Tallyfy go beyond traditional process improvement methods? Traditional process improvement relies on periodic workshops, manual data collection, and suggestion boxes. These methods can be slow and disconnected from actual work. Tallyfy offers two built-in features that accelerate your improvement efforts - contextual **improvement comments** and **AI capabilities**. Here's how they work. ### How do contextual comments capture insights at the source? The best way to find improvement opportunities? Listen 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/) makes this easy. You don't need any special setup: - **In-context feedback**: When a team member hits an issue, gets confused, or has a better idea for completing a task, they can comment directly on that specific step within an active process. Feedback gets captured immediately, right where it's relevant. - **No lost ideas**: Suggestions aren't lost in emails, forgotten in meetings, or scribbled on sticky notes. They're permanently attached to the process step, available for review by process owners and managers. You'll always know where to find them. - **Collaborative problem-solving**: Comments spark discussions among team members directly within Tallyfy, helping teams identify and refine potential improvements together. ### How does AI-powered process creation provide intelligent suggestions? Tallyfy uses AI to make process management and improvement smarter: 1. **AI for initial process capture**: Getting existing processes documented is often the first hurdle. Tallyfy's AI helps you start faster. It's designed to overcome that "blank page" problem: * Describe your process in plain language, and Tallyfy AI generates a draft [template](/products/pro/documenting/templates/). * Upload legacy documents (like Word checklists or procedural outlines), and Tallyfy AI converts them into structured, ready-to-use templates. * *Benefit*: This overcomes "blank page syndrome" and quickly gets your processes into a format you can analyze, run, and improve. 2. **AI-driven improvement suggestions (emerging capability)**: As Tallyfy gathers data on how your processes run (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 can provide intelligent suggestions. This could include: * Identifying steps that are frequently commented on as problematic. * Suggesting reordering of steps based on observed inefficiencies. * Highlighting steps that are good candidates for automation or simplification. * *Benefit*: AI acts as an always-on assistant, spotting patterns that might be missed in manual reviews and speeding up the improvement cycle. ### How do comments, AI, and rapid iteration create a continuous improvement cycle? Together, these features create a fast-moving cycle for continuous process improvement: 1. **Execute and observe**: Teams run processes using Tallyfy templates. 2. **Capture insights**: Users provide in-context feedback and improvement ideas via **comments** on tasks. 3. **Analyze and suggest**: Process owners review comments. **AI** analyzes process data and comment patterns to highlight issues or suggest improvements. 4. **Refine and implement**: Process owners update the Tallyfy **template**. Because [template updates are instant](/products/pro/documenting/templates/edit-templates/) for all new process launches (no versioning delays), improvements deploy immediately. 5. **Monitor and repeat**: The improved process runs, performance is tracked via **analytics**, and the feedback loop continues with new comments. This agile loop makes process improvement a dynamic, ongoing part of your operations - it's not a periodic project. - **[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/)**: Turn customer feedback into measurable Critical to Quality (CTQ) requirements using the Kano Model and CTQ Trees. Design Tallyfy processes around what customers actually value and track delivery with deadlines and analytics. ## Translating customer needs into measurable goals Process improvement works best when it's focused on what actually matters to your customers. Before improving a process, you need to understand their needs, expectations, and what they value. This means capturing the **Voice of the Customer (VOC)** and turning it into measurable **Critical to Quality (CTQ)** requirements. ### Capturing the Voice of the Customer (VOC) VOC is the collective needs, expectations, and feedback your customers express about your products, services, or processes. Here are common ways to listen in an office or service environment: - **Surveys**: Collect feedback on satisfaction, specific process touchpoints, or overall experience. - **Interviews**: Run one-on-one discussions with a representative sample of customers to uncover their perspectives and pain points. - **Feedback forms**: Embed simple feedback mechanisms within your Tallyfy processes or at the end of service delivery. - **Support tickets and complaints**: Analyze patterns in customer issues - they often point directly to process gaps. - **Social media and review sites**: Monitor what customers say about you publicly. - **Sales and account management teams**: Frontline teams often have valuable insights into customer sentiment and needs. :::note[Focus on listening] When gathering VOC, the 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 carry the same weight. The Kano Model helps you prioritize by categorizing them: - **Must-bes (basic expectations)**: Unspoken requirements customers absolutely expect. Missing them causes extreme dissatisfaction - but meeting them doesn't increase satisfaction. They're just the baseline. *Example: In a Tallyfy-managed onboarding process, a **Must-be** is that all required legal documents are correctly processed.* - **One-dimensionals (performance needs)**: The more you deliver, the more satisfied customers become (and vice-versa). Customers are usually vocal about these. *Example: The faster the onboarding process completes in Tallyfy, the happier the client.* - **Delighters (excitement needs)**: Unexpected positives that create a "wow" effect. Customers don't ask for these. *Example: Sending an unexpected personalized welcome kit halfway through the Tallyfy onboarding process could be a **Delighter**.* Knowing where your process outcomes fall on the Kano Model helps you maintain Must-bes, excel at One-dimensionals, and strategically add Delighters. ### Defining Critical to Quality (CTQ) requirements CTQs translate qualitative customer needs into specific, measurable process characteristics. They bridge the gap between what customers say they want and what your processes 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** is a visual tool that breaks down broad customer needs into granular, measurable CTQs. Start with a general need, then ask "what does that mean?" or "how would we measure that?" to get specific. ### Designing Tallyfy processes around CTQs Once you've identified your CTQs, design or modify your processes so they consistently meet these requirements. Tallyfy helps you build processes with CTQs front and center: - **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**: Meet quality-related CTQs by providing detailed instructions, checklists, or video guides within Tallyfy tasks. - **Track performance**: Use Tallyfy's real-time tracking and [analytics](/products/pro/integrations/analytics/) to monitor whether your processes consistently hit CTQ targets (e.g., on-time completion, error rates). :::tip[Customer feedback in Tallyfy] Add a dedicated step in your Tallyfy [customer-facing templates](/products/pro/documenting/templates/) (like order fulfillment or service delivery) to request feedback. Tailor questions to gather input on aspects tied to your key CTQs. ::: - **[Implementing and sustaining improvements](https://tallyfy.com/products/pro/tutorials/how-to/process-improvement/implementing-changes-and-sustaining-improvements-with-tallyfy/)**: Tallyfy makes process improvements permanent by embedding changes directly into workflow templates. Analytics and feedback tools help teams monitor results and catch backsliding without relying on training that fades within a week. ## How can I make process improvements stick? Embed your changes directly into Tallyfy workflows - don't rely on training alone. A great improvement idea is only half the work. Rolling it out and keeping it going is where the DMAIC "Improve" and "Control" phases matter most. ### Implementing changes effectively Traditional training fails because of the [Ebbinghaus forgetting curve](/products/pro/tutorials/why-documentation-training-fails-forgetting-curve/) - people forget 90% of what they learn within a week. Instead of relying on memory, build the new process right into the workflow. **How to do it in Tallyfy:** Modify your [procedure templates](/products/pro/documenting/templates/) or [document templates](/products/pro/documenting/documents/). Every new [process](/products/pro/tracking-and-tasks/processes/) launched from that template automatically uses the updated version. There's no paper redistribution and no outdated copies floating around. ### Sustaining improvements over time Making improvements is one thing - making them last is another. Here's how Tallyfy helps: * **Standardization** - When people run processes inside Tallyfy, they follow the new standard by default. Accidental deviations become much harder. * **Visibility and monitoring** - Use [Tallyfy Analytics](/products/pro/integrations/analytics/) and the [Tracker view](/products/pro/tracking-and-tasks/tracker-view/) to check whether people are following the new process and it's delivering results (faster completion times, fewer errors, etc.). * **Feedback loops** - Use [Tallyfy's comment features](/products/pro/tracking-and-tasks/tasks/how-can-i-manage-comments-in-tallyfy/) to gather ongoing feedback. This lets your team flag issues and suggest tweaks, reinforcing a culture of continuous improvement. * **Regular reviews** - Schedule periodic reviews of key processes. Tallyfy's data helps you spot whether things are still running well or if new bottlenecks have crept in. - **[Integrating Agile and Design Thinking into process improvement](https://tallyfy.com/products/pro/tutorials/how-to/process-improvement/integrating-agile-and-design-thinking/)**: Combine Agile sprints, Design Thinking, and Lean Six Sigma to run faster improvement cycles. Test small changes quickly, scale what works, and use Tallyfy for instant deployment. ## How can Agile and Design Thinking accelerate improvements? Traditional process improvement feels slow and rigid. Projects drag on for months, solutions address symptoms instead of root causes, and teams lose momentum waiting for perfect data. Agile brings iterative speed and continuous feedback. Design Thinking adds creative problem-solving and empathy. Combined with Lean Six Sigma's rigor, you get 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. **Sprint-based delivery**: Deliver improvements incrementally instead of analyzing for months. Week 1: Fix the obvious bottleneck. Week 2: Simplify the handoff. Week 3: Automate the routine task. Each sprint produces real 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 surfaces issues immediately. **Kanban boards for visual management**: Make improvement work visible. Create columns for "To Do," "In Progress," "Testing," and "Done." 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 reordering two steps - implemented in one day instead of waiting for a full process redesign. ### Design Thinking: reimagining what's possible Lean Six Sigma excels at optimization. Design Thinking enables transformation - shifting focus from "How do we fix this process?" to "How might we delight our customers?" **The five stages in process improvement**: 1. **Empathize**: Understand users' real experiences, not just process metrics. Shadow customer service reps for a day. Listen to customer calls. 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. 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 what you learn. ### Practical integration strategies **Start with Design Thinking for breakthrough innovation**: When facing complex customer problems, 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 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. Break changes into two-week chunks. Test with small groups. Scale what works. **Use Lean Six Sigma for fine-tuning**: After Agile implementation, apply Six Sigma tools to measure results and identify remaining waste. Standardize best practices. An insurance company that reorganized into case teams later used statistical analysis to find the right team sizes and skill mixes. ### Creating psychological safety for innovation Innovation requires risk-taking. Risk-taking requires safety. - **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 lessons 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 into one focused week: - Day 1: Map the challenge and pick a target - Day 2: Sketch competing solutions - Day 3: Decide which ideas to prototype - Day 4: Build a realistic prototype in Tallyfy - Day 5: Test with real users **Scrum for continuous improvement teams**: - **Product Owner**: Process owner who prioritizes improvements - **Scrum Master**: Guides the team and removes obstacles - **Development Team**: 3-7 people who implement improvements - **Sprints**: 2-week cycles of focused improvement work ### Using Tallyfy for agile improvement Tallyfy supports agile, iterative improvement out of the box: **Rapid prototyping**: Clone templates to test changes without affecting live processes. **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 right away. ### Common integration pitfalls **Analysis paralysis meets wild ideation**: 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, each one strengthens the others: - 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 blended approach to customer onboarding. Design Thinking revealed customers wanted transparency, not just speed. Agile sprints tested status notifications quickly. Lean removed redundant steps. Six Sigma ensured consistency. The result: significantly faster onboarding and much higher satisfaction scores. Process improvement isn't about choosing one approach - it's about blending them for your context. Start where you are, use what works, and keep evolving your approach. - **[Introduction to DMAIC](https://tallyfy.com/products/pro/tutorials/how-to/process-improvement/introduction-to-dmaic-for-process-improvement/)**: DMAIC is a five-phase method (Define, Measure, Analyze, Improve, Control) from manufacturing that offers a structured, data-driven approach to solving process problems by targeting root causes rather than symptoms. It ensures improvements last through standardization and continuous monitoring. ## How does DMAIC support process improvement? When you hit a process problem, it's tempting to jump straight to a fix. But without a structured approach, you'll likely treat symptoms instead of root causes. **DMAIC** gives you a proven five-phase method that keeps changes data-driven and lasting. DMAIC stands for: - **D**efine - **M**easure - **A**nalyze - **I**mprove - **C**ontrol This approach evolved from manufacturing at companies like Motorola and General Electric, where reducing defects to near-zero was critical. Today, DMAIC works just as well for service processes - from client onboarding to invoice processing. ### Why systematic improvement matters Consider this: 99% accuracy sounds impressive, right? At that level, we'd still see 20,000 lost articles of mail per hour and 5,000 incorrect surgical operations per week. DMAIC provides the discipline to achieve breakthrough improvements, not just incremental gains. ### Define: what is the problem and what are the goals? The Define phase pins down what you're solving, who it affects, and what success looks like. Key activities: - **Problem statement**: State the issue concisely (e.g., "Client onboarding averages 15 days, causing dissatisfaction."). - **Goal statement**: Set specific, measurable targets (e.g., "Reduce average onboarding to 7 days within 3 months."). - **Scope**: Draw boundaries around the process under review. - **People involved**: Identify who's affected by the process and the improvement effort. This phase often produces a **Project Charter** summarizing these points. A well-crafted charter becomes your North Star throughout the project. #### Precise problem statements matter Half the battle is won when you define the problem correctly. Avoid these 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?) Use the 5W1H approach instead - 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 key people**: Note who'll be affected or involved. ### Measure: how does the process currently perform? You can't improve what you haven't measured. The Measure phase collects data to establish a baseline and pinpoint problem areas: - Identify key metrics (e.g., cycle time, error rates, customer satisfaction scores). - Develop a data collection plan. - Gather and validate the data. #### Understanding variation - your process's fingerprint Every process has variation. The key question: is yours predictable (common cause) or unpredictable (special cause)? A coffee shop has slight brewing time differences - that's normal. A broken espresso machine creates abnormal delays. Managing by averages alone misses this distinction. Smart measurement reveals patterns: - **Cycle time distribution**: Not just "average 5 days" but 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? Customers experience your full 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? With data in hand, the Analyze phase digs into the root causes behind your process problem. This means asking "why" repeatedly until you move past symptoms. Common techniques include the **5 Whys** and **Fishbone Diagrams** (covered in [Simple root cause analysis techniques](/products/pro/tutorials/how-to/process-improvement/simple-root-cause-analysis-techniques/)). #### Moving past surface-level analysis Teams too often 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 80% of delays happen in just one step nobody noticed. Elapsed time doesn't equal effort time. A task might take 3 days but only need 30 minutes of actual work - the rest is waiting. See [how to track time spent on tasks](/products/pro/tutorials/how-to/track-time-in-tasks/) to capture real effort data. Good analysis combines multiple angles: - **Process analysis**: Where does work get stuck? Which handoffs fail? - **Data patterns**: Do problems cluster around certain times, customers, or conditions? - **Human factors**: What makes the process hard to execute consistently? Most process problems stem from the system, not the people. W. Edwards Deming 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 you've identified root causes, the Improve phase is about brainstorming, evaluating, and testing solutions: - Generate a range of improvement ideas. - Select the most promising based on impact and feasibility. - Pilot solutions on a small scale to test effectiveness. #### Solution design basics Great solutions share common traits - they're simple, foolproof, and target root causes rather than symptoms. Some proven 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 do tasks. Everyone performs at the level of your best operator. Always pilot before full rollout. What works in theory might fail in practice. Small-scale tests reveal unexpected issues while the stakes are 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 make improvements stick? The Control phase keeps improvements from regressing to old habits: - Standardize the new process. - Monitor performance continuously. - Create a plan for handling future deviations. #### Building sustainability in An uncomfortable truth: 70% of improvement initiatives fail to sustain gains after 18 months. Why? Organizations treat Control as an afterthought. Effective control needs three elements: **Process discipline**: The new way must be easier than the old way. If people need to remember 10 new rules, they'll revert under pressure. Build 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. 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. ### Quick wins vs. transformation Not every problem requires a full DMAIC project. Use this guide to decide your approach: **Quick wins** (Days to weeks): - Single-step problems - Clear root cause - Known solution - Few people involved **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 DMAIC 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. - **[Kaizen - continuous small improvements](https://tallyfy.com/products/pro/tutorials/how-to/process-improvement/kaizen-making-continuous-small-improvements-with-tallyfy/)**: Kaizen focuses on small, continuous improvements rather than big overhauls. Tallyfy supports this approach by letting teams leave feedback on tasks, instantly update templates, and identify quick wins that add up over time. ## How can small, consistent process changes create powerful results? **Kaizen**, a Japanese term meaning "change for good", is a philosophy of making small, ongoing improvements to reduce waste and boost quality. Instead of big overhauls, everyone in the organization contributes small changes regularly. ### Why is Kaizen effective for office processes? Kaizen works especially well in fast-moving office and service environments: - **Less disruptive**: Small changes won't derail daily operations. - **Gives everyone a voice**: People doing the work spot the best improvements, which builds ownership and engagement. - **Reduces resistance**: Incremental tweaks face far less pushback than radical transformations. - **Builds a learning culture**: Each small change is a chance to learn and refine, creating a cumulative effect over time. - **Low cost, high impact**: Many small improvements need minimal investment but add up to significant gains in efficiency and quality. ### What are the core principles of Kaizen? - **Small, incremental changes**: Aim for many minor improvements rather than a few large ones. - **Involve everyone**: Ideas should come from all levels, especially people directly involved in the process. - **Never stop**: Kaizen isn't a one-time event. It's a continuous effort woven into daily work. - **Standardize improvements**: Once a change is validated, it becomes the new baseline to build on. - **Question everything**: Keep asking whether there's a better way. Think of it like tidying a room. A massive one-off clean-up can be daunting, but spending 5-10 minutes tidying a small part each day keeps things consistently neater. ### How does Tallyfy make Kaizen practical? Tallyfy fits naturally into a Kaizen approach to process improvement: 1. **Contextual feedback with comments**: Team members can leave [improvement comments directly on specific tasks](/products/pro/tracking-and-tasks/tasks/how-to-report-and-resolve-issues-in-tallyfy/) whenever they spot issues or think of better ways to do things. This captures in-context suggestions that might otherwise be lost. It's your built-in Kaizen suggestion box, right where work happens. 2. **AI-powered suggestions**: Tallyfy is moving toward using AI to analyze patterns in process execution and comments. This means Tallyfy can highlight areas for small improvements or suggest refinements based on collective team feedback. 3. **Instant template updates**: Quick action on small improvements is central to Kaizen. When you [edit a Tallyfy template](/products/pro/documenting/templates/edit-templates/), changes go live immediately for all new processes launched from it. No versioning delays or lengthy rollouts. 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/) let teams discuss improvement ideas before implementing them. 5. **Easy process modification**: Adjusting a step, adding a clarification, or reordering tasks in a template is simple and doesn't require specialized skills. This lowers the barrier to frequent small changes. :::tip[Build a Kaizen habit] Encourage your team to spot small improvement opportunities as they work through Tallyfy tasks. Spend a few minutes each week in team meetings reviewing suggestions from comments and picking quick wins to implement. ::: - **[Measuring process performance with sigma levels](https://tallyfy.com/products/pro/tutorials/how-to/process-improvement/measuring-process-performance-with-sigma-levels/)**: Sigma levels measure process quality as defects per million opportunities (DPMO). Learn how this metric reveals why even 99% quality allows thousands of errors, and how to set targets from 3 sigma for internal workflows to 6 sigma for life-critical processes. ## What are sigma levels and why do they matter? Sigma levels measure process quality as defects per million opportunities (DPMO). This gives you a universal metric to compare different processes - invoice accuracy, on-time delivery, anything - and set targets based on world-class benchmarks instead of arbitrary percentages. Most organizations sit between 2 and 4 sigma. At 3 sigma (93.3% defect-free), performance sounds good. But that's 66,807 defects per million opportunities. For a hospital, that's unacceptable medication errors. For a bank, thousands of incorrect transactions. ### 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 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 ### How to calculate your process sigma You need three concepts: 1. **Defect opportunities**: Each customer requirement is a chance 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 can have multiple defects. One incorrect invoice (defective) might have wrong amount AND wrong address (two defects). 3. **Sample size matters**: Your data should represent 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 **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 calculate cycle times and completion rates automatically - Process health indicators show trends over time - Export data for detailed sigma calculations **Drive improvement**: - Comments capture why defects happen - Pattern analysis reveals common failure points - A/B test process changes to raise sigma levels ### Setting meaningful targets Don't set arbitrary goals like "reduce errors by 50%." Use sigma levels for context-appropriate targets instead: **Life-critical processes** (healthcare, aviation): Target 5-6 sigma - Even small error rates have severe consequences - Near-perfection pays off in lives saved **Financial processes** (billing, payroll): Target 4-5 sigma - Errors directly hurt customer trust and regulatory compliance - Prevention costs less than correction **Internal processes** (expense reports, meeting scheduling): Target 3-4 sigma - Balance improvement costs with business impact - Prioritize customer-facing processes first ### Common pitfalls in sigma measurement **Measuring activities, not outcomes**: Tracking "emails sent" rather than "customer issues resolved" misses the point. Measure what customers value. **Ignoring hidden factories**: Rework often hides in unmeasured activities. A "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 are useful, but keep perspective: - **Context matters**: 4 sigma might be excellent for one process, inadequate for another - **Costs escalate**: Moving from 3 to 4 sigma typically costs far less than 5 to 6 - **Culture matters**: Higher sigma levels demand systematic thinking, not heroic efforts The goal isn't perfection everywhere - it's the right quality level for each process. Use sigma levels to decide where improvement investment will have the most customer impact. - **[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 thinking applies Toyota''s waste-elimination approach (TIM WOODS) to office work by defining customer value and removing non-value-adding steps through five core principles. Tallyfy embeds these ideas into daily workflows. ## Applying lean principles in office work Lean thinking maximizes customer value while minimizing waste. It started in manufacturing (famously at Toyota), but its principles work just as well for office and service processes. The core idea is eliminating "Muda" - the Japanese term for waste - meaning any activity that burns resources without creating value for the customer. 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." That mindset changes how you see every process - from invoice handling to customer onboarding. ### Customer value definition Before eliminating waste, you need to understand what your customer actually values. Value is what the customer would pay for - what meets their explicit and implicit needs. Any step that doesn't contribute to this value is potentially waste. (See [Identifying customer needs and CTQ requirements](/products/pro/tutorials/how-to/process-improvement/identifying-customer-needs-and-critical-to-quality-ctq-requirements/) for more.) ### The 8 wastes (TIM WOODS) in office contexts Lean practitioners use the acronym **TIM WOODS** for the eight categories of waste. Here's how each one shows up in office and service environments: 1. **T - Transportation**: Unnecessary movement of information, documents, or people for approvals and handoffs. * *Office example*: Emailing document drafts back and forth for review instead of using a Tallyfy task with files attached. Routing a physical document through multiple departments for signatures when an e-signature step would do. * *Tallyfy helps*: Centralizes information and tasks so you don't move data between systems unnecessarily. Clear assignments minimize misrouted work. 2. **I - Inventory**: Excess work-in-progress, task backlogs, unread emails, outdated reports, or 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*: Gives visibility into workloads and queues via the [Tracker view](/products/pro/tracking-and-tasks/tracker-view/). Deadlines and automated reminders keep work flowing. 3. **M - Motion**: Unnecessary physical movements (walking to a shared printer repeatedly) or digital movements (excessive clicks, navigating complex folder structures, switching between applications). * *Office example*: Searching across shared drives and email chains to find client information. Opening and closing different apps to copy-paste data. * *Tallyfy helps*: Puts all task-relevant information, instructions, and forms in one place. Integrations automate data transfer, cutting down on app switching. 4. **W - Waiting**: Idle time waiting for information, approvals, decisions, or a previous step to finish. * *Office example*: A project stalled because a decision-maker isn't available. An employee stuck waiting for data from another department. * *Tallyfy helps*: Automated notifications alert assignees when tasks are ready. Deadlines and task status visibility help spot and reduce wait times. You can configure parallel steps for tasks that should happen simultaneously. To measure 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 needed, sooner than needed, or in greater quantities than needed - like creating reports nobody reads. * *Office example*: Generating a daily detailed sales report when management only reviews a weekly summary. Preparing a full proposal before qualifying the client. * *Tallyfy helps*: Processes launch on demand. [Conditional logic (rules)](/products/pro/documenting/templates/automations/logic-explained/) ensures only necessary steps activate, preventing premature work. 6. **O - Over-processing**: Putting more effort into a task than the customer values - unnecessary checks, excessive reviews, or multiple approval layers for minor items. * *Office example*: Requiring three management sign-offs for a minor supply order. Reformatting a document repeatedly to satisfy slightly different internal preferences. * *Tallyfy helps*: Simplifies approvals with clear assignment. Standardized templates reduce unnecessary variations. Conditional logic can skip approval steps based on defined criteria. 7. **D - Defects**: Errors that require correction - rework, delays, and unhappy customers. Data entry mistakes, incorrect calculations, 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 tasks help prevent errors. Standardized processes reduce defects from inconsistent methods. 8. **S - Skills (unused talent)**: Failing to use your team's knowledge, creativity, and experience. Also includes assigning tasks to people without the right skills or burdening skilled workers 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. * *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/) let everyone contribute ideas. :::tip[Conduct a waste walk] Review your Tallyfy templates step by step. For each one, ask your team: "Does this step show any of the TIM WOODS wastes from the customer's perspective or from an efficiency standpoint?" ::: ### The five lean principles Lean thinking rests on five principles that work together: 1. **Specify value from the customer's standpoint**: Start every process design by asking "What would the customer pay for?" A mortgage application 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 find that value-adding time is a small fraction of total cycle time. Many organizations discover their multi-week approval processes contain only minutes of actual work. 3. **Create flow**: Arrange work so it moves without interruption. Break down departmental silos, reduce batch sizes, and eliminate 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. **Pursue perfection through continuous improvement**: 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. Instead of Monday morning chaos and Friday afternoon lulls, distribute work evenly. HR teams often cut overtime by spreading interview scheduling throughout the week rather than 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. You get consistency while still allowing necessary variation. **Visual management**: Make work status instantly visible. Tallyfy's tracker view acts 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 Making your processes visible, standardized, and executable in Tallyfy makes waste easier to spot and eliminate. Tallyfy 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 built in**: Comments and analytics reveal improvement opportunities - **[Simple root cause analysis techniques](https://tallyfy.com/products/pro/tutorials/how-to/process-improvement/simple-root-cause-analysis-techniques/)**: Root Cause Analysis uses techniques like the 5 Whys and Fishbone diagrams to trace process problems to their true origins. These methods work best as team exercises where different perspectives uncover hidden causes that drive lasting fixes. ## How can I find the real reasons behind process problems? Fixing symptoms gives temporary relief. Fixing **root causes** stops problems from coming back. Root Cause Analysis (RCA) is a set of techniques that help you trace a problem back to its real source. Here are two practical methods that work well for office and service environments. ### How does the 5 Whys technique work? The **5 Whys** is simple: state the problem, then keep asking "Why?" - usually about five times - until you reach a fundamental cause. **How to use the 5 Whys:** 1. **Define the problem clearly**: Start with a specific statement. Example: "The monthly sales report was submitted two days late." 2. **Ask "Why?"**: Why did the problem occur? * *Problem*: The monthly sales report was submitted two days late. * *Why?* The data from the CRM system wasn't available on time. 3. **Ask "Why?" again**: Take the answer and ask why that happened. * *Why wasn't the CRM data available?* The CRM had unscheduled downtime on the data extraction day. 4. **Keep asking "Why?"**: Repeat for each answer. * *Why did the CRM have unscheduled downtime?* An emergency patch was applied without proper testing. * *Why was the patch applied without testing?* The IT team felt pressured to fix an urgent bug quickly. * *Why did the IT team feel pressured?* There's no clear protocol for balancing urgent fixes with testing requirements. 5. **Identify the root cause(s)**: By the fifth "Why" (sometimes earlier or later), you'll uncover a deeper systemic issue. Here, the missing IT protocol is the real root cause - not just "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/), use the comment thread to run a collaborative 5 Whys session. Each "Why" and its answer becomes a reply in the thread, keeping the analysis in context. ### How does the Fishbone diagram help identify problem causes? The Fishbone Diagram (named for its fish skeleton shape) is a visual tool that helps teams brainstorm and categorize potential causes of a problem. **How to create a Fishbone Diagram for office processes:** 1. **Define the problem (the "head")**: Write the problem statement at the "head" of the fish, on the right side. 2. **Draw the "spine"**: Draw a horizontal line extending left from the problem. 3. **Identify cause categories (the "bones")**: Brainstorm broad categories. For office processes, common ones include: * **People**: Skills, training, communication, motivation. * **Process**: Workflow issues, unclear steps, handoffs, policies. * **Technology**: Software, hardware, systems, data. * **Environment/Policy**: External factors, company policies, workspace issues. Draw diagonal lines branching off the spine, labeling each with a category. 4. **Brainstorm specific causes**: For each category, list specific causes as smaller "bones" branching off the main ones. * *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**: Discuss the most likely causes and plan next steps - perhaps running 5 Whys on the top suspects or gathering data via Tallyfy Analytics. ### Visualizing the Fishbone diagram This diagram shows a Fishbone analysis for why support tickets aren't resolving satisfactorily. [Diagram removed for brevity] **What to notice:** - The problem statement (fish head) sits at the right as the focal point - Main categories branch off like bones, organizing causes into logical groups - Specific causes connect to their categories, showing how individual issues feed into the bigger problem **Tallyfy tip for Fishbone Diagrams:** Tallyfy doesn't have a built-in Fishbone tool, but you can create one on a whiteboard (physical or virtual) and attach a photo or summary to a relevant Tallyfy task or template description. The insights can then drive improvements in your process. :::note[Collaborative effort] Both the 5 Whys and Fishbone Diagrams work best as team exercises. Different perspectives help uncover causes that one person alone would miss. ::: ### Advanced techniques for harder problems The 5 Whys and Fishbone work well for straightforward issues. Harder problems may need these additional 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 helps you prioritize where to spend your effort. **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 generates frequency data you can use for Pareto analysis. #### Failure mode and effects analysis (FMEA): prevent problems before they happen FMEA identifies what could go wrong before it does. Originally from aerospace, it's valuable for any critical business process. **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 tip**: Build prevention into templates based on FMEA findings. Add checkpoints where high-risk failures might occur. #### Statistical thinking for service processes Numbers reveal patterns you can't spot by casual observation. A few useful techniques: **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 piled up and overwhelmed Monday morning staff. Solution: stagger Monday start times. **Scatter Diagrams**: Plot one factor against another to spot correlations. Example: Plotting "training hours" against "error rates" for new employees showed a strong negative correlation - 20+ hours of training dramatically cut errors, justifying the 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 Analysis without action is wasted effort. Make sure findings drive real change: 1. **Document findings**: Attach RCA results to relevant Tallyfy processes 2. **Link to solutions**: Every root cause should connect to a specific process change 3. **Verify effectiveness**: Did addressing the root cause actually solve the problem? 4. **Share learnings**: Similar processes often have similar vulnerabilities - **[Streamlining change management](https://tallyfy.com/products/pro/tutorials/how-to/process-improvement/streamlining-change-management-with-tallyfy/)**: Process improvement depends on managing the human side of change. Tallyfy helps by letting teams suggest improvements in workflows, instantly deploying updated templates, and guiding users step-by-step through new tasks. ## Why change management matters in process improvement Improving a process isn't just about designing a better workflow - it's about managing the **transition for the people involved**. Resistance, confusion, and poor training can derail even well-designed improvements. **Change management** guides individuals and teams from the current state to the desired future state. Tallyfy's built-in features simplify this work. ## Key challenges in managing process changes Implementing process changes typically faces these hurdles: - **Resistance to change** - People stick to routines, and change can feel threatening. - **Poor communication** - If you don't communicate the reasons and details well, confusion and opposition grow. - **Insufficient training** - Team members don't feel confident performing tasks the new way. - **Fear of the unknown** - Ambiguity about what the change means causes anxiety. - **Outdated documentation** - SOP manuals go stale quickly, creating confusion about the current process. ### How Tallyfy simplifies change management Tallyfy reduces or eliminates many traditional change management challenges: 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 builds buy-in because the changes are, in part, their own ideas. 2. **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 runs the same current standard. 3. **Instant deployment** - When you [edit a Tallyfy template](/products/pro/documenting/templates/edit-templates/), changes take effect immediately for all new instances. No confusion about when a new process starts or which version to use. 4. **Built-in training and guidance** - Tallyfy's task interface guides users through the new process with step-by-step instructions, checklists, and embedded media built directly into tasks. Users learn by doing, which cuts the need for formal training sessions that [fail due to the forgetting curve](/products/pro/tutorials/why-documentation-training-fails-forgetting-curve/). 5. **Transparency and visibility** - Everyone can see the process flow, their assigned tasks, and work status. This reduces uncertainty and helps team members understand how their role fits in - even after changes. 6. **Incremental change reduces fear** - Tallyfy makes it easy to implement small improvements (supporting a Kaizen approach). Smaller changes are less intimidating and easier to adapt to than large, infrequent overhauls. :::note[Communicating changes effectively] While Tallyfy makes the *technical* deployment of changes easy, still communicate the *why*. Use Tallyfy announcements, team meetings, or a note in the updated template description to explain the reasons and benefits. ::: - **[Understand process flow without flowcharts](https://tallyfy.com/products/pro/tutorials/how-to/process-improvement/understanding-process-flow-without-complex-flowcharts/)**: Tallyfy replaces static flowcharts with live sequential templates where each step has clear assignments and deadlines. Track real-time progress through the Tracker view, spot bottlenecks with analytics, and fix flow issues by reordering steps, adding conditional logic, or running parallel tasks. ## How can I visualize how work moves using Tallyfy templates? **Process flow** is the sequence of steps, activities, and handoffs that transform inputs into outputs. Understanding this flow helps you find bottlenecks, delays, and areas for improvement. Tallyfy offers a more intuitive way to visualize and manage your workflow than traditional diagrams. ### Why is understanding process flow important? A clear view of your process flow helps you: - **Find bottlenecks** - Pinpoint where work piles up or slows down. - **Spot delays and queues** - See where tasks wait too long before someone acts on them. - **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. - **Reduce cycle time** - Shorten the path work takes from start to finish. ### How does Tallyfy's approach compare to traditional flowcharts? Detailed flowcharts and Value Stream Maps (VSMs) work well in complex manufacturing settings. But for office and service-based processes, they're often too complicated to create, maintain, and understand. **Tallyfy simplifies process flow:** 1. **Define sequentially** - When you [create a template](/products/pro/documenting/templates/edit-templates/), you're 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 **[process status page](/products/pro/tracking-and-tasks/tracker-view/how-can-i-manage-and-track-my-processes-on-tallyfy/)** show real-time progress. You see completed steps, the current active step, and what's coming next. 3. **Handoffs are clear** - Task assignments show who's responsible for each part of the flow. When one person completes their task, it automatically moves to the next assignee. ### How can I identify flow issues in Tallyfy? Because your processes are live and tracked in Tallyfy, spotting flow problems is straightforward: - **[Tracker view](/products/pro/tracking-and-tasks/tracker-view/)** - This board gives you a bird's-eye view of all active processes. Look for steps where many tasks pile up - those are your bottlenecks. - **[Tallyfy Analytics](/products/pro/integrations/analytics/)** - Check the data for: - Average time per step: Steps with significantly longer durations are potential constraints. - Overdue tasks: Many overdue tasks at one step signals a flow problem. - **[Task comments](/products/pro/tracking-and-tasks/tasks/how-to-report-and-resolve-issues-in-tallyfy/)** - Frequent comments about delays, missing information, or confusion at a specific step indicate flow issues. ### What simple strategies can improve process flow in Tallyfy? Once you've found areas for improvement, Tallyfy makes it easy to adjust the flow: - **Reorder steps** - If a sequence is illogical or causing delays, drag and drop steps in your template editor. - **Clarify instructions** - Ambiguity causes delays. Make instructions within Tallyfy tasks crystal clear. - **Use [conditional logic (rules)](/products/pro/documenting/templates/automations/logic-explained/)** - Automate routing to skip unnecessary steps based on specific criteria. - **Improve handoffs** - When a task moves between assignees, make sure the Tallyfy task includes all necessary information. This cuts delays from information-seeking. - **Use parallel steps** - If activities can happen simultaneously, configure them as parallel steps in Tallyfy to speed up the overall process. - **[Understanding your current processes](https://tallyfy.com/products/pro/tutorials/how-to/process-improvement/understanding-your-current-processes-with-tallyfy/)**: Documenting existing workflows in Tallyfy eliminates tribal knowledge by letting teams capture real processes as step-by-step templates. Use plain language or AI-powered drafts instead of complex flowcharts, and the living documentation stays current every time a process runs. ## Why is documenting existing workflows the starting point? You can't improve what you don't understand. Many office workflows are undocumented, vaguely defined, or exist only as "tribal knowledge" passed down informally. That's a major barrier to improvement. ### Why should I document my processes? Making your processes explicit gives you: - **Clarity and consistency** - Everyone knows the right way to do things, producing more consistent outcomes. - **Faster training** - Documented processes help onboard new team members quickly. - **A baseline for improvement** - A clear "as-is" process lets you measure changes against something concrete. - **Visible inefficiencies** - The act of documenting a process often reveals redundancies, bottlenecks, or unnecessary steps. Traditional approaches involve detailed flowcharts or process maps. These often become complex, quickly outdated, and are typically created by specialists - making them less accessible to the people actually doing the work. ### What advantages does Tallyfy offer for understanding processes? Tallyfy gives you a straightforward way to understand and document your processes: - **No flowcharts needed** - You define your process by listing steps in order, assigning roles, adding rules, and embedding instructions. The Tallyfy template *becomes* your process map - clear, practical, 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. Your documentation stays up-to-date automatically. - **AI-powered process capture** - Describe a process in plain language, or upload existing documents (like old Word files or checklists), and Tallyfy's AI will generate a first draft of your 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 request physically moving through your office. "Process Stapling" means you follow that item from start to finish - noting every person it touches and every action taken. As you do this, input these steps directly into a Tallyfy template to capture the real flow of work. ::: ### What key information should I capture in Tallyfy? Use the **SIPOC** model (Suppliers, Inputs, Process, Outputs, Customers) to guide what you capture - even without formal diagramming: - **Process steps** - The individual tasks in your Tallyfy template. - **Inputs** - What information, documents, or resources does each step need? Capture these in Tallyfy form fields or as attachments. - **Outputs** - What does each step produce? What's the final outcome? - **Suppliers (of inputs)** - Who or what system provides the inputs for each step? - **Customers (of outputs)** - Who receives each step's output, and who's the ultimate customer of the overall process? - **Roles and responsibilities** - Tallyfy's assignee feature makes it clear who's responsible for each step. ### How can I gain initial insights from process documentation? Even before launching a documented process, reviewing the steps, assignees, and instructions with your team can reveal pain points and spark improvement discussions. :::note[Use comments for early feedback] While documenting a process into a Tallyfy template, encourage your team to use the **comment feature** on steps where they have questions, notice inconsistencies, or see quick improvement opportunities. This captures valuable insights from the start. ::: - **[Process improvement](https://tallyfy.com/products/pro/tutorials/how-to/process-improvement/what-is-process-improvement/)**: Process improvement means analyzing workflows and making targeted changes to cut waste, reduce errors, and boost efficiency. Tallyfy makes processes visible and trackable so teams can spot bottlenecks and lock in better ways of working. ## What is process improvement and what are its benefits? **Process improvement** means analyzing how work gets done today and making targeted changes so it works better tomorrow. If your team deals with repetitive tasks, frustrating delays, or recurring errors - those are signs your processes need attention. A **process** is a series of steps taken in a specific order to achieve an outcome. Client onboarding, support requests, monthly reports - your organization runs on processes. The goal is straightforward: compare your current state ("as-is") with where you want to be ("to-be"), then close the gap. It's about asking, "How can we do this better?" ### Why does process improvement matter? Better processes deliver real, measurable results: - **Higher efficiency and productivity** - Less wasted time and effort. When Tallyfy automates parts of client onboarding, your team can focus on higher-value work instead of manual data entry. - **Fewer errors** - A clear, step-by-step process in Tallyfy for financial reports cuts calculation mistakes and missed data points. - **Happier customers** - Faster, more reliable service builds loyalty. When support issues get resolved quicker and more consistently, customers stick around. - **Lower costs** - Less rework, fewer wasted resources, and smarter allocation all hit the bottom line. - **Stronger employee morale** - Clunky processes frustrate people. Clear workflows in Tallyfy reduce stress and let employees focus on meaningful work. - **Greater agility** - Teams that continuously improve their processes adapt faster to market changes and customer demands. ### How does this apply beyond the factory floor? Lean and Six Sigma started in manufacturing, but their principles work everywhere. In an office, "waste" isn't scrap metal - it's time spent searching for information, unnecessary approval steps, or duplicated data entry. Think of your workflows like a city's road system. Poorly designed roads with potholes and confusing signs cause traffic jams, late deliveries, and frustrated drivers. Process improvement upgrades that road system for everyone. Tallyfy makes office processes visible and manageable - the first step to finding and eliminating waste. ### How does Tallyfy support process improvement? Tallyfy makes your processes explicit, trackable, and easy to modify. That means you'll identify, test, and lock in improvements quickly. This guide covers specific methods and techniques, with practical examples of how Tallyfy's features help you apply them. ### Documenting - **[Documents](https://tallyfy.com/products/pro/documenting/documents/)**: Tallyfy's document templates let you create locked-down policies and reference materials with editable fill-in-the-blank fields. Every team produces consistent branded documents without starting from scratch or managing multiple Word file versions. ## What are document templates? Document templates in Tallyfy let you create policies, reference materials, and guides where people don't need to follow a strict sequence. They're smart forms[^1] - your standard text and formatting stays locked, but editable fields let users add their specific details. Unlike [procedure templates](/products/pro/documenting/templates/) built for sequential workflows, document templates work best for information sharing that doesn't need task sequencing or dependencies. You can also publish document templates in [knowledge-only mode](/products/pro/tutorials/knowledge-only-mode/) - making them searchable reference materials without launching a formal process. Great for policies, guidelines, and SOPs that people need to read but not track. ### Why use document templates? - **Brand consistency** - every document looks the same across all teams (fonts, layout, appearance) - **Speed** - users fill in the blanks instead of starting from scratch - **Protection** - standard content stays locked, so nobody can accidentally break it - **Central updates** - change the template once and all future documents reflect it - **Any device** - works on phone, tablet, or computer with no downloads needed ### How they're structured Document templates have two parts: 1. **Fixed content** - your standard text, formatting, headers, footers. Users can't edit these sections 2. **Editable fields** - the blanks users fill in (names, dates, specific details) ### What you can create - **Corporate policies** (social media guidelines, remote work rules, code of conduct) - **Procedural guidance** (client communication scripts, 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) ### Launching a document template When you launch a document template: 1. Tallyfy creates a fresh copy as an active process you can track 2. Users can only change the fields you've marked as editable - everything else stays locked 3. Every completed document matches your template's intended format ### Tallyfy documents vs. traditional files Tallyfy documents fix common problems with traditional file-based documents: - **Auto-formatting** - templates handle fonts and margins automatically - **Clear boundaries** - editable fields are highlighted, locked content isn't touchable - **Single version** - one document, one location. No "Final_v3_REALLY_final.docx" problem - **Snippets** - use snippets[^2] to drop reusable text blocks across documents - **Translation** - built-in content translation for global teams - **Cross-platform** - same experience on phones, tablets, and computers ### Tallyfy documents vs. Microsoft Word | Feature | Tallyfy documents | Microsoft Word | |---------|-------------------|----------------| | **Main use** | Online reading and collaboration | Primarily print-focused | | **Formatting** | Consistent company-wide style, auto-cleaned text | Manual formatting per document | | **Table of contents** | Auto-generated from headings | Manual creation and updates | | **Version control** | Single version with tracked changes | Multiple file versions | | **Collaboration** | Role-based access tied to workflows | File sharing with limited live co-editing | | **Images** | Web-optimized with sizing options | More print formatting options | :::tip[Moving from Word to Tallyfy] When copying from Word, bring over the text first, then structure it with Tallyfy headings (H1, H2, H3). Tallyfy strips Word's formatting on paste, so your documents stay clean and consistent. ::: [^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/)**: Groups in Tallyfy are saved lists of team members and external guests that let you assign tasks to an entire team with one click. They automatically stay current when someone joins or leaves your organization. ## What are groups? Groups let you assign tasks to entire teams at once - saved lists of people you work with regularly. Pick the group instead of adding people one by one. ### Benefits - **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 removed from all groups automatically - **Smooth transitions** - new members get added once and they're ready to go If you're running the same workflows every week or month, groups save you from repetitive setup work. ### Group composition example An "Accounting Team" group might contain: - Jane Doe (member) - Jill Ramirez (member) - tim.smith@gmail.com (guest[^1]) You can mix internal team members with external partners in the same group. Your auditor, consultant, or client can work right alongside your staff. ### Automatic membership management 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 smoothly with your team (still free and unlimited) - Membership stays current without manual effort [^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/)**: Tallyfy lets you bring external clients and partners into your workflows as free guests who complete specific tasks through secure email links without needing full accounts or logins while internal team members maintain oversight and control over the entire process. ## Guest access 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 - completely free with unlimited access. This makes guests ideal for [client onboarding](https://tallyfy.com/solutions/client-onboarding-software/) where external people need to participate. Example: You're running a 20-step approval process, but steps 5 and 12 need client input. Guests complete their parts right within your workflow. Everything stays tracked in one place. :::tip[Member vs. Guest: Employee badge vs. visitor pass] - **[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 areas based on their role - **Guest:** Like a **visitor** with a temporary **visitor pass**. They don't get a full login. Their pass is the unique *forever link[^1]* sent via email. This link gives access *only* to the specific task they need to work on. They can't see other tasks or processes Guests participate in specific tasks without getting access to your whole Tallyfy account. ::: ### Assigning tasks to guests Assign any step to an email address outside your organization - that person becomes a guest. When building your template, you've got three assignment options: - **Specific people or teams** in your organization - **Job titles** like "Account Manager" or "Project Lead" - **External email addresses** for clients and partners who need to complete certain steps Every guest task must also have an internal assignee. You need someone inside your organization keeping tabs on external participation. ### Security and access #### Secure access links - **Unique forever links**: Each guest gets a private link to access tasks. It stays the same unless you change their email or manually reset it via **Settings > Guests**. No passwords needed. - **Direct access**: Click the link, complete the task. No account creation, no login screens. #### Visibility and delegation - **Controlled visibility**: Guests only see their assigned tasks - nothing else. Your internal workflow stays confidential. (If you make a process [public](/products/pro/tracking-and-tasks/processes/make-a-process-public/), guests can see everything in the Tracker view.) - **Task delegation**: Guests can reassign their tasks to colleagues by adding their email addresses. #### Internal oversight - **Mandatory internal assignment**: Every guest task needs an internal assignee too. Someone in your organization always has visibility into external tasks. - **Automated reminders**: Tallyfy sends reminder emails automatically. You don't need to chase clients for responses. #### Customization and management - **Daily digest**: Guests can switch to daily digest emails if they prefer fewer notifications. - **Communication history**: Check what emails went to a specific guest at **Settings > Guests** - every reminder, every notification. Useful for audit trails. - **Language settings**: Guests can change their display language (`app_language`) and content language (`content_language`) through their preferences. ### Guest email preferences Guests have limited email control compared to members. **What guests CAN control**: - Daily digest emails (on/off) - combine all notifications into one daily summary - Display language and content language preferences **What guests CANNOT control**: - Individual task notification emails - always sent when tasks are assigned - Comment notification emails - always sent when someone comments - Deadline reminder emails - always sent as deadlines approach If a guest needs more email control, consider: - Converting them to a Light member[^2] role - Using member-level permissions instead of guest access ### Guest task completion **How guests complete tasks**: - Email notifications include a direct link to the task - The green **Complete** button is prominently displayed - Automatic reminders follow your configured cadence - Task descriptions can include step-by-step instructions **Tips for clearer guest tasks**: - Add explicit instructions like "Click the green Complete button when done" - Use numbered steps 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. Good 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 - **[Members](https://tallyfy.com/products/pro/documenting/members/)**: Members in Tallyfy are your organization's users who hold one of three roles: Administrator for full control, Standard for daily workflow tasks, and Light for task-only access. Each role determines what features that person can reach. ## What are members in Tallyfy? Members are people in your organization with Tallyfy access - employees, contractors, or anyone who works on processes regularly. Unlike [guests](/products/pro/documenting/guests/), members have full account access and count toward your subscription limits[^1]. ### The three member roles Each member gets one of three roles: - **Administrator** - Full control over settings, members, and system configuration. Only give this to trusted people. - **Standard** - The most common role. Full workflow capabilities with specific permissions that admins can customize per person. - **Light** - Can complete assigned tasks and give feedback, but can't create or edit templates. Ideal for people who follow processes rather than design them. :::tip[Think of roles like key card access levels] - **Administrator:** Master key card - enters all areas, changes security settings, controls who gets access. - **Standard:** Department key card - accesses work areas and rooms needed for their job, but not org-wide settings. - **Light:** Task-only key card - enters assigned areas to complete work, but can't access template design areas. ::: ### Role categories - **Full roles** - Administrator and Standard both count as "Full" members for billing purposes - **Light roles** - For team members who only 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 - **[Templates](https://tallyfy.com/products/pro/documenting/templates/)**: Tallyfy templates are reusable blueprints you create once and launch repeatedly. They assign tasks, send reminders, and track progress across three types: procedures, documents, and forms. ## Working with templates Templates are reusable blueprints that turn your processes into trackable workflows. Create once, reuse forever. When you launch a template, Tallyfy creates a live process - assigning tasks, sending reminders, and tracking progress automatically. Update a template once and every future process gets the fix. ### The three-stage approach 1. **Document** - Capture your process knowledge in a template 2. **Run** - Launch consistent, trackable processes every time 3. **Improve** - Improve based on real data and feedback ### Common problems templates solve Every time someone asks "How do we do this again?", you're losing money. Templates fix that. - **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 become your single source of truth. Fix the template once, everyone benefits instantly. :::note[Template vs. Blueprint] In the Tallyfy app, we call these **Templates**. In the Tallyfy API, they're called **Blueprints** (or "checklists" internally). Same thing, different names. ::: ### Key benefits - **Same process, same quality** - every client gets your A-game service - **Create once, use 1000x** - launch that onboarding template for every new hire in seconds - **Zero interpretation** - clear steps mean no confusion - **Scale without chaos** - handle 10x more work with the same team ### Template types Tallyfy has three template types: 1. **Procedure templates** - multi-step workflows that run from start to finish. - All tasks appear at once by default (parallel). 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, groups, or job titles[^1] - Collect data with form fields that validate entries - Connect to your other tools via integrations :::note[Tallyfy approach vs. flowcharts] Instead of flowcharts, Tallyfy uses a checklist style for steps, combined with "if-this-then-that" rules. This makes processes easier to understand and follow while still handling decisions and different paths. ::: 2. **Document templates** - policies, handbooks, and reference materials. - Lock down sections that can't change (legal disclaimers stay perfect) - Add fill-in fields for custom details - Use snippets[^2] - update once, changes flow to all documents instantly 3. **Form templates** - structured data collection forms for gathering information without a multi-step workflow. Use procedure templates when you need trackable multi-step workflows. Use document templates for reference materials. Use form templates for standalone data collection. ### 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 launching a formal process. Good for: - How-to guides and SOPs teams reference while working - Training materials and best practices - Company policies and guidelines ### Template lifecycle #### 1. Creation - **From scratch** - build custom workflows step by step - **AI-powered** - describe your process, Tallyfy generates the template - **Upload existing docs** - turn a Word SOP into a live workflow - **Clone and tweak** - copy an existing template and modify it #### 2. Management - **Folders** - organize by team, client type, or frequency - **Tags** - filter by "customer-facing" or "compliance" instantly - **Permissions** - control who can view, edit, launch, or duplicate each template - **Ownership** - assign a template owner who's responsible for updates - **Archive** - soft-delete templates from active view without permanent removal #### 3. Launch - **Kick-off form** - fill in details, Tallyfy handles the rest - **Pre-set assignments** - tasks go to the right people, groups, or job titles automatically - **Live tracking** - see exactly where every process stands :::note[Template vs. Process: Building analogy] A **template** is like a **master blueprint** for a house. It defines the standard design. **Launching a process** is like building a specific house from that blueprint. Each house (each running process) is unique and needs its own name so you can track it separately. ::: ### Can I nest a template inside another template? Yes - two ways: 1. **Content embedding** - use [snippets](/products/pro/documenting/templates/snippets/) to embed reusable content within task descriptions. 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 add another template's steps into a running process. ## Template organization Templates not placed in folders appear in the **Uncategorized** view. The Uncategorized folder is a system folder that can't be deleted. To organize templates: 1. Go to **Templates** and select **Uncategorized** 2. Click the folder icon next to any template 3. Choose **Move to folder** and pick or create a destination folder ## Next steps Learn how to [create a template](/products/pro/documenting/templates/create-template/). [^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 ### Documents - **[Add fields to documents](https://tallyfy.com/products/pro/documenting/documents/how-can-i-add-editable-fields-to-my-tallyfy-documents/)**: Tallyfy's document templates let you insert editable short text, long text, and date fields into otherwise locked content so that anyone launching the template only fills in the blanks once and every instance comes out consistent. ## 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. This keeps every document consistent. ### Requirements - You'll need edit permissions for document templates. - Know which parts of your document need editable [fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) - what changes each time? ### Types of editable fields Tallyfy's document editor supports three [field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) types: 1. **Short Text** - Names, titles, reference numbers. 2. **Long Text** - Paragraphs and detailed explanations. 3. **Date** - Deadlines, start dates, and similar. ### Adding new fields ### Reusing existing fields You can place the same field in multiple spots without creating it twice: ### How fields work in launched documents When someone [launches](/products/pro/launching/) a document template with [fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/): - They fill in the editable fields. That's it. - If the same field appears in multiple places, they enter it once and it populates everywhere. - All other content stays locked. - Documents come out consistent every time. ### Tips for using document fields - **Name fields clearly.** "Customer Name" prevents confusion. "Name" causes headaches. - **Match field size to content.** Short Text for company names, Long Text for detailed project descriptions. - **Group related fields together.** - **Don't go overboard.** Too many fields overwhelm users. Keep it focused. - **Test first.** [Launch](/products/pro/launching/) your own [document template](/products/pro/documenting/documents/) before sharing it with others. - **[Digital signatures](https://tallyfy.com/products/pro/documenting/documents/how-can-i-automate-document-signing-with-tallyfy/)**: Tallyfy can automatically send documents for e-signature through services like DocuSign or HelloSign by using webhooks and middleware tools so that when a user completes a workflow step the collected form data flows directly into a signature request and optionally reports back to Tallyfy when the document is signed. ## How to automate document signing using 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]. ### What you'll need - A Tallyfy account with [webhook](/products/pro/integrations/webhooks/) access - A [middleware](/products/pro/integrations/middleware/) account (Zapier, Power Automate, or Make.com) - An e-signature service account (DocuSign or HelloSign) - A document template ready in your signature service :::note[Setting up middleware] If you haven't used middleware before, check the [middleware integration guide](/products/pro/integrations/middleware/) for setup instructions and platform comparisons. ::: ### How it works ### Document signing automation flow [Diagram removed for brevity] **Key points:** - **Steps 2-3**: The webhook fires[^2] when someone completes a Tallyfy step - no manual triggers needed - **Step 4**: Middleware handles field mapping - set it up once and it works every time - **Steps 7-8**: The optional return path means Tallyfy knows when documents get signed without you checking ### Step 1: Create a webhook listener in your middleware ### Step 2: Set up your Tallyfy process ### Step 3: Connect your e-signature service in the middleware #### For HelloSign #### For DocuSign ### Step 4: Test and activate ### Tracking when the document is signed You can set up a return path so Tallyfy knows when documents get signed: The end result: 1. Someone completes a Tallyfy step - document goes out for signing. 2. Recipient signs the document. 3. Tallyfy updates to show the signing task is done. [^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 generates a clickable table of contents from your document and procedure template headings in real time, so you don't have to manually create or refresh navigation links. ## How automatic table of contents work in Tallyfy Tallyfy builds a table of contents from your headings automatically. Add headings, and the navigation appears - no manual linking or 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 differs from Word Word's table of contents needs manual refreshing, page numbers break, and formatting fights you. Tallyfy works differently: - **Instant creation** - add a heading and it appears in 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** - you'll never manually update navigation again ### Creating a table of contents in documents Your headings instantly appear in the table of contents panel as clickable links. ### Tips for using headings well - **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'll still get automatic navigation, but you access it through preview mode: ### Why automatic table of contents matter An automatic table of contents gives readers: - A clear view of your document's structure in seconds - One-click jumps to any section - no scrolling marathons - A reason to organize content logically (this makes your docs better, too) - Equal ease of navigation whether a document is 5 or 50 pages [^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 automatically generates documents like contracts and PDFs by connecting form field data through middleware to services like WebMerge or DocuSign. Setup takes about 15 minutes and eliminates manual data copying. ## How to auto-generate documents from Tallyfy form data Create contracts, reports, or signature requests directly from Tallyfy form responses - it takes about 15 minutes to set up. ### 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, or HelloSign) ### How it works When someone completes a task in Tallyfy, a webhook fires with all form field data[^2]. [Middleware](/products/pro/integrations/middleware/) catches that webhook and sends the data to your document service - which creates PDFs, Word files, or triggers signature requests. No manual copying. ### 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 [^1]: Task IDs use a non-incrementing string format unique to each task instance [^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/)**: Launch document instances from any template in your Library. Fill in editable fields through a kick-off form, and Tallyfy merges your data with the template's fixed content to produce a printable document you can edit anytime. ## How to create document instances from templates Click **Launch Document** on any template card in your **Library** to create a new document instance. You'll fill in editable fields through a kick-off form, and Tallyfy merges your data with the template's fixed content. You can launch as many instances as you need from a single [Document Template](/products/pro/documenting/documents/). Each one is independent. ### How to launch That's it. Tallyfy creates your document instance, populated with the data you entered. ### Viewing and editing the launched document [^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/)**: Tallyfy lets you create groups of members and guests in Settings to assign entire teams to template steps at once instead of individually. You can also control how many group members take on each task. Groups let you bundle people together so you don't have to assign them to tasks one by one. ## What you'll need - Admin or Standard [member](/products/pro/documenting/members/) permissions - Access to **Settings** ## Creating a group :::tip[Using groups for recurring guests] Create groups with guest emails you use often (like your client's team). You won't have to re-type those addresses every time. ::: ## Assigning groups to template steps ## Group assignment options - **Maximum assignees[^2]** - limits how many people from the group can work on one task. Set this at the organization level. - For dynamic assignments that change based on process conditions, use [assignment actions](/products/pro/documenting/templates/automations/actions/asignment-actions/). :::note[How group assignments work] When you assign a [task](/products/pro/tracking-and-tasks/tasks/) to a group, the person launching the process picks who actually gets it - specific people from the group or everyone. In templates, you can only assign the whole group or specific individuals. Once a process is running, any group member can 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/)**: Tallyfy lets you assign workflow tasks to external guests like clients and vendors via secure email links without requiring accounts or paid seats and provides tools to track their progress and convert them to full members when needed. ## How to assign, manage, and convert guests Guests are external people - clients, vendors, contractors - who can complete tasks in your workflows without creating a Tallyfy account. They're free and unlimited on paid plans. ### Guests vs. members | Feature | Guest users | Members | |---------|------------|----------------| | Cost | Free, unlimited | Paid seat | | Account needed | No | Yes | | Can create templates | No | Yes (Standard/Admin) | | Can launch processes | No | Yes | | Task visibility | Only assigned tasks | All tasks (based on role) | | Authentication | Secure email link | Login credentials | | Can post comments | Yes (unless disabled per task) | Yes | ### How to assign tasks to guests Two options: 1. **In a template** (repeatable processes): - Select a step in your template - Go to the **Assignment** tab - Choose "Guest" as the assignment type - Enter the guest's email address 2. **In an active process** (on-the-fly): - Open the task you want to assign - Click **Reassign** - Select "Assign to guest" - Enter the guest's email address - Click **Save** When assigned, guests receive an email with a secure link to their task[^1]. No passwords. No account creation. ### Guest notifications and tracking You can: - Customize the email notification message - Set up reminder notifications for uncompleted tasks - Track when guests access their tasks (via the `last_accessed_at` timestamp) The Tracker view shows which guest tasks are complete, pending, or in progress. Guests can also see @mentions directed at them in task comments. ### Common guest use cases **Collecting information from customers** - Use guest tasks to gather data through forms, collect document uploads, get approvals, or request feedback. **Involving external experts** - Legal reviews, technical consultations, vendor approvals. Guests contribute to specific steps without full user accounts. **Onboarding new clients** - Create a process that walks clients through every step: submitting documents, filling out forms, and receiving information as they go. ### Document collection workflows Great for loan applications, mortgage processing, or compliance checks. Set up tasks where guests can: - See required documents with explanations - Upload files directly to their tasks - Check off completed items - Get clear instructions at every step ### Troubleshooting guest access #### Guest can't access their task 1. Double-check the email address for typos 2. Guest emails can't match your organization's domain. If your org uses `mydomain.com`, guests with `@mydomain.com` emails won't work - they'll need a different email address 3. Resend the invitation from the task view 4. Confirm the process is still active (completed processes lock everyone out) 5. Verify the task hasn't been reassigned The domain restriction (#2) catches most people. #### Guest completed a task by mistake 1. Go to the completed task 2. Click **Reopen** in the task menu 3. The task returns to active status 4. The guest can access it again with their original link #### Changing a guest's email Click **Reassign** on the task, enter the correct email, and click **Save**. Tallyfy sends a fresh invitation to the new address. The old link stops working immediately. ### Security and privacy #### What guests can and can't see **Guests CAN see:** - Their assigned tasks - Attachments and 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 :::warning[Important security consideration] When you make a process **[Public to the world](/products/pro/tracking-and-tasks/processes/make-a-process-public/)**, guests can see **all tasks** in the Tracker view - including tasks assigned to other guests or members. Keep processes private when: - Different guests shouldn't see each other's work - Task titles or descriptions contain sensitive information - You need strict task-level access control ::: #### Guest security tips - Share only what's necessary in guest tasks - Use form fields to collect information instead of exposing sensitive details - Keep confidential data out of task descriptions and attachments - Use the **Reset link** option in **Settings > Guests** to invalidate old guest links when needed - Review and remove guest access when projects finish ### Converting between guests and members #### Converting a guest to a member You need Administrator permissions and an available member seat. ##### Method 1: Convert from the Guests list ##### Method 2: Invite as a member 1. Go to **Settings > Members** 2. Click **Invite member** 3. Enter the guest's email address 4. Select the role (Standard, Light[^2], or Administrator) 5. Click **Send** ##### What happens after conversion - They receive a temporary password email - They're initially set as a Standard member (changeable later) - They occupy a paid member seat - Adjust their role in **Settings > Organization > Members** #### Converting a member to a guest Administrators can convert a member in one step - active or deactivated, no need to disable them first. Tallyfy deactivates active members automatically during the conversion: 1. Go to **Settings > Members** 2. Find the member 3. Click the three-dot menu and select **Convert to guest** They can still complete guest tasks but won't have member privileges. See [Convert a member to a guest](/products/pro/documenting/members/convert-member-to-guest/) for details. ### Advanced guest features #### Guest form submission without task assignment Create a process with a form, generate a shareable link, and send it out. Anyone with the link can submit the form - useful for surveys, registrations, or feedback collection. #### Custom branding for guest interfaces Customize the guest experience with your logo, welcome messages, and branded email notifications. Task descriptions can reflect your organization's voice and style. [^1]: Links contain a unique guest_code token that authenticates without requiring account credentials [^2]: Light users have view-only permissions and can't complete tasks, unlike guest users who can complete assigned tasks - **[Re-open completed guest tasks](https://tallyfy.com/products/pro/documenting/guests/how-can-i-re-open-a-completed-guest-task/)**: Only members with Administrator or Standard permissions can re-open completed guest tasks in Tallyfy. Guests can't revert their own submissions, and re-opening automatically changes task 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 it themselves. This keeps decisions final and prevents confusion in later steps. If a guest needs to add information after submitting, they can: - Add comments to the completed task - Ask a [member](/products/pro/documenting/members/) 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 - The guest task must already be completed ### Steps to re-open a guest task Only members can do this - not guests themselves: ### Sending the task link again After re-opening 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 also leave comments there. - **[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 in Tallyfy let external people access and complete assigned tasks without logging in. Find these links from the task's three-dot menu in a running process or from the guest list in Settings. ## Finding and sharing guest task links [Guest](/products/pro/documenting/guests/) task links are URLs that let external people access specific [tasks](/products/pro/tracking-and-tasks/tasks/) without a Tallyfy account. No login required. These links stay active even after the guest completes their task, so you can [reopen](/products/pro/documenting/guests/how-can-i-re-open-a-completed-guest-task/) completed tasks when needed. ### What you need - The [task](/products/pro/tracking-and-tasks/tasks/) must already be assigned to a [guest](/products/pro/documenting/guests/) - You'll need Administrator or Standard [member](/products/pro/documenting/members/) permissions ### Method 1: From the task itself The quickest way when you're already looking at the task: ![Copy guest link option in the task three-dot menu](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-copy-guest-link.png) ### Method 2: From the guest list in Settings Use this when you need links for multiple guests or can't remember which process contains their task: ![Copy guest link from the guest list in Settings](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-copy-guest-link-from-settings.png) ### Sharing the link :::tip[Programmatic access to guest URLs] You can also retrieve guest URLs programmatically through the Tallyfy API: 1. Query process tasks via the API 2. Extract the `taskUrls` array from the task's `owners` object 3. Send these URLs through your own email/SMS systems 4. Use webhooks to capture URLs when tasks are created ::: Once you've copied the link: - Paste it anywhere - email, Slack, text message - When the [guest](/products/pro/documenting/guests/) clicks it, they'll land directly on their assigned task - no login screens or password resets - The link stays active as long as the task exists - **[The guest view](https://tallyfy.com/products/pro/documenting/guests/how-can-guests-monitor-their-processes-on-tallyfy/)**: Tallyfy's guest dashboard is a passwordless hub where external users can view all assigned tasks across processes. Guests complete work by filling in forms, uploading files, tracking progress, and managing notification preferences. ## 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/). It's your single place to find and complete work. ### How to access your dashboard Two ways in: 1. Click the **[task link](/products/pro/documenting/guests/how-to-find-a-guest-task-link-in-tallyfy/)** in your email notification 2. Visit [https://go.tallyfy.com](https://go.tallyfy.com/) and enter your email address No passwords needed[^1]. ### What you'll see - **Process list** - every [process](/products/pro/tracking-and-tasks/processes/) where you have work to do - **Task cards** - your specific assignments - **Status markers** - whether tasks are pending, in progress, or complete - **Comments** - ask questions or post updates on any task - **Attachments** - files attached to each task - **Due dates** - deadlines for your tasks ### Viewing process details 1. Find the [process](/products/pro/tracking-and-tasks/processes/) on your dashboard 2. Click its name to open the detailed view 3. You'll see all [tasks](/products/pro/tracking-and-tasks/tasks/) assigned to you within that process ### Working on tasks 1. Click the [task](/products/pro/tracking-and-tasks/tasks/) you want to complete 2. Review the instructions 3. Fill in any [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) or upload required files 4. Add comments if you have questions 5. Click **Complete** when you're done ### Tracking progress - Completed tasks show a checkmark - Your current task is highlighted - Future tasks show when they'll unlock[^2] - A progress bar shows how far along the process is ### What guests can do As a [guest](/products/pro/documenting/guests/), you can: - Complete [tasks](/products/pro/tracking-and-tasks/tasks/) assigned to you - View and download files attached to your tasks - Leave comments, ask questions, and report problems on tasks - Track overall progress of your [processes](/products/pro/tracking-and-tasks/processes/) - Choose which days of the week you receive email digest notifications :::note[Managing notifications] To adjust your email digest schedule, open the settings area in your guest view. You can pick any combination of days from Monday through Sunday. ::: [^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/)**: Assign tasks to external guests by entering their email address in a template or running process. Guests receive a secure link to complete their work without needing an account or password. ## How to assign tasks to guest users Enter a [guest's](/products/pro/documenting/guests/) email address when assigning any [task](/products/pro/tracking-and-tasks/tasks/), and they'll get a secure link[^1] to complete their work - no account needed. ### What you need - Administrator or Standard [member](/products/pro/documenting/members/) permissions (Light members can't assign guests) - The guest's email address - A [template](/products/pro/documenting/templates/) or running [process](/products/pro/tracking-and-tasks/processes/) with the task you want to assign :::note[Guest email restrictions] You can't assign guest tasks to email addresses that already belong to a member in your organization. If your org uses SSO, guest emails also can't match your configured company domains. ::: ### Method 1: Assign when building the template Set up guest assignments in your template so every process launch assigns the right external people automatically. When someone [launches](/products/pro/launching/) this template, Tallyfy automatically assigns the task to your specified guest. :::note[Assigning many tasks quickly] Use the [Power Assign](/products/pro/documenting/templates/how-can-power-tools-enhance-my-tallyfy-experience/) tool to assign many tasks to guests at once in a template. ::: ### Method 2: Assign in a running process You can assign tasks to guests even after a [process](/products/pro/tracking-and-tasks/processes/) is already running. The guest receives an email with a secure link to view and complete their task - no account or password needed. ### Method 3: Assign using a comment You can assign a [guest](/products/pro/documenting/guests/) by typing `+` followed by their email in a [task](/products/pro/tracking-and-tasks/tasks/) comment. Example comment: ``` +guest.email@example.com Please review this. ``` Tallyfy assigns the guest to the task as soon as the comment posts. This works in both [templates](/products/pro/documenting/templates/) and running [processes](/products/pro/tracking-and-tasks/processes/) - handy when you're already discussing the task in comments. ### What happens after assignment Once you assign a task to a [guest](/products/pro/documenting/guests/): - They get an email with a secure [link](/products/pro/documenting/guests/how-to-find-a-guest-task-link-in-tallyfy/) to their task - They click the link and complete the task - no login required - Multiple tasks appear on their personal [guest dashboard](/products/pro/documenting/guests/how-can-guests-monitor-their-processes-on-tallyfy/) - You'll see "Completed" status in your [process view](/products/pro/tracking-and-tasks/tracker-view/) once they finish :::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? Required to register it properly 2. **Task not active yet** - Guests only get notified when their task becomes active (not while it's waiting) 3. **Email in spam folder** - Ask the guest to check spam/junk and whitelist tallyfy.com 4. **Member co-assignment** - At least one member must also be assigned 5. **Wrong email address** - Verify spelling and that it's not already a member in your org 6. **Process not launched** - Template assignments only take effect after the process launches 7. **Owner re-assignment** - If removing the process owner causes them to be re-added, keep the owner assigned and add the guest as a co-assignee 8. **UI issues** - Try refreshing the page, check your permissions, or use a different browser Find the guest link manually: **Settings** > **Organization** > **Guests** to resend. ::: ### Managing guest task assignments - View all guests: **Settings** > **Organization** > **[Guests](/products/pro/documenting/guests/)** - Resend a lost guest link from the [guest links](/products/pro/documenting/guests/how-to-find-a-guest-task-link-in-tallyfy/) page - Track progress in your [process dashboard](/products/pro/tracking-and-tasks/tracker-view/) - Reassign tasks to different people at any time ### Member co-assignment with guest tasks When you assign a task to a guest, Tallyfy automatically co-assigns a member to that task. :::caution[Guest-only assignment not allowed] At least one internal member must be co-assigned to any guest task. If you remove all members, Tallyfy automatically keeps or adds a member. ::: **Why this exists**: 1. **Comment routing** - Guest comments need a member to receive notifications 2. **Oversight** - Members can approve guest work and track progress 3. **Guest limitations[^2]** - Guests can't @-reply internal members (the member list is private to guests) **Impact on your task list**: - Guest tasks appear in your personal task list until completed - If you assign 10 guest tasks, you'll have 10 pending tasks yourself - These stay "active" for you even while the guest works on them **Tip**: Designate specific team members as guest task coordinators to centralize oversight rather than spreading it across many people. Use filters to separate your own work from guest oversight tasks. [^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 - **[Guests](https://tallyfy.com/products/pro/documenting/guests/what-is-a-guest/)**: Guests are external people like clients and suppliers who complete workflow tasks through secure email links without needing accounts or paid seats. They can only see their assigned tasks, keeping your internal data protected. ## What is a guest in Tallyfy? [Guests](/products/pro/documenting/guests/) are people outside your company (clients, suppliers, contractors) who complete specific [tasks](/products/pro/tracking-and-tasks/tasks/) in your workflows. They don't need Tallyfy accounts or paid seats. Guests receive secure email links to their tasks, complete them, and that's it. No logins required. ### Key characteristics - **External people**: Clients, suppliers, contractors and business partners who participate in specific parts of your workflows - **No account needed**: Guests participate without creating 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 - **Limited visibility**: Guests only see their assigned tasks. They can't access your other [processes](/products/pro/tracking-and-tasks/processes/) or company data - **Data protection**: Your internal data stays hidden from guests ### Common uses for guests - Getting approvals from clients - Asking external people to review documents - Collecting information from suppliers for purchasing - Gathering customer feedback - Getting sign-offs from partners ### Member vs guest comparison #### What members can do - Log into Tallyfy with 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 organization (based on their role) - [Invite](/products/pro/documenting/members/how-to-invite-and-activate-members-on-tallyfy/) other members and guests - Occupy 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 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 can't 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 aren't involved in - [Start new processes](/products/pro/launching/) - See tasks assigned to other people - Log into the main Tallyfy platform - Use email addresses that already belong to a member of your organization Guests can delegate their tasks to other external people through self-delegation[^1]. See [how to assign tasks to guests](/products/pro/documenting/guests/how-can-i-assign-tasks-to-guest-users-in-tallyfy/) for details. ### Guest vs Light vs Standard member comparison | 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. Guests can't see all processes or log in directly. If contractors need broader access or work on multiple processes regularly, give them Light member status so they can track their work across all assigned processes. ::: :::important[Email domain restrictions for SSO organizations] **In SSO-enabled organizations, guests can't use your company's email domain.** If your company uses `yourcompany.com`, you can't assign `anyone@yourcompany.com` as a guest. They must be a Light or Standard member instead. For non-SSO organizations, the system checks that the email doesn't already belong to an existing member. ::: [^1]: Self-delegation creates a new guest_code link that can be forwarded to another external person ### Members - **[Change a member's role](https://tallyfy.com/products/pro/documenting/members/how-can-i-change-a-members-role-in-tallyfy/)**: Administrators can change any member's role between Administrator, Standard, and Light by going to Settings > Organization > Members. Select a new role from the dropdown and it takes effect immediately. ## How to change a member's role Go to **Settings** > **Organization** > **Members**, click a member's name, and pick a new role from the dropdown. Only Administrators can do this - 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 roles Tallyfy has three [member roles](/products/pro/documenting/members/): - **Administrator** - Full control over templates, processes, settings, and member management - **Standard** - Can work with processes and templates based on permissions you set - **Light** - For occasional users who only need to complete assigned [tasks](/products/pro/tracking-and-tasks/tasks/) ### Steps to change a role The change takes effect immediately. ### Role changes and your seat pools Administrator and Standard both use a **full** seat, and Light uses a **light** seat, so moving someone between those two groups moves them between your two pools. * **Moving someone up to Standard or Administrator** needs a free full seat. If your full pool is already used up, Tallyfy refuses the change and offers to sell you more seats rather than quietly putting you over your commitment. You aren't stuck: buy the seat from that prompt and the change goes through. * **Moving someone down to Light is never refused.** It hands a full seat back, so Tallyfy always lets it through, even if you don't have any light seats committed. Your plan trues up at renewal. * **Switching between Administrator and Standard isn't a pool change at all**, since both draw a full seat, so it's never blocked. Guests are free and unlimited and sit outside both pools. Converting a guest into a member does consume a seat, so that conversion can be refused when the pool is full. ### When to change roles - Promoting someone to manage the whole Tallyfy setup? Give them Administrator access - Have a contractor who only works on specific [tasks](/products/pro/tracking-and-tasks/tasks/) occasionally? Switch them to Light - Team member switching departments? Update their role to match new responsibilities You can change roles anytime. If someone needs temporary higher access, switch them back later. ### Removing members from your organization You can't directly delete members, but you can deactivate them: 1. Go to **Settings** > **Organization** > **Members** 2. Click on the member's name 3. Click the button to disable their account 4. Confirm the action 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 - **[Manage member permissions](https://tallyfy.com/products/pro/documenting/members/how-do-i-manage-member-permissions-in-tallyfy/)**: Administrators can control what Standard members do in Tallyfy. Set five permissions (edit, read, launch, view, and duplicate) at both the template and running process level to manage who sees and changes your workflows. ## How to control what team members can do Go to any template's **Config** settings or a running process's **Settings** panel, then adjust the permission checkboxes for each Standard member. ### What you need - Administrator [role](/products/pro/documenting/members/) - Standard [members](/products/pro/documenting/members/) whose permissions you want to manage ### Types of permissions As an Administrator, you control exactly what Standard members can and can't do. Five permission areas apply per template: 1. **Edit** - Can this person change specific [templates](/products/pro/documenting/templates/)? One wrong edit affects every future process. 2. **Read** - Can they see specific templates in the library? 3. **[Launch](/products/pro/launching/)** - Can they start new [processes](/products/pro/tracking-and-tasks/processes/) from specific templates? 4. **View processes** - Can they find and view running processes from this template? 5. **Duplicate** - Can they duplicate this template? ### Setting permissions for a specific template :::note[Hiding templates from users] To completely hide a template from Standard or Light users[^1], you must restrict **all** template-level permissions - Edit, Read, and Launch at minimum. If even one box is checked, the template stays visible in their library. ::: ### Setting permissions for a running process You can hide specific running processes from certain team members. ### Tips for managing permissions - **Template editing is powerful** - one accidental change to a [template](/products/pro/documenting/templates/) affects every future process launched from it. Only give this to people who understand your workflows. - **Don't over-restrict process visibility**. If someone needs to collaborate on running [processes](/products/pro/tracking-and-tasks/processes/), they need view access. Being too restrictive creates bottlenecks. - **[Process launching](/products/pro/launching/) needs training**. Make sure people understand a workflow before giving them launch permissions. - **Review permissions regularly** - especially after promotions, role changes, or department transfers. - **Use groups, not individuals**. Permissions can be assigned per group, which is much easier than managing person by person. [^1]: Light users have view-only permissions and can't complete tasks or edit templates - **[Convert a member to a guest](https://tallyfy.com/products/pro/documenting/members/convert-member-to-guest/)**: Tallyfy converts a member to a guest in one step. An administrator clicks Convert to guest on the member, Tallyfy deactivates the account automatically if needed, switches them to guest-only access via email task links, and frees up a paid member seat. ## How to change a member into a guest Click **Convert to guest** on the member you want to change. That's it - one step. Tallyfy deactivates their member account automatically as part of the conversion, so you don't need to deactivate them first. This helps when someone was invited as a [member](/products/pro/documenting/members/) by mistake and should have been a [guest](/products/pro/documenting/guests/), or when a teammate moves outside your company but still needs to complete the occasional task. ### What you need - Administrator permissions - only admins can convert members. - The person must be a [member](/products/pro/documenting/members/) of your Tallyfy organization. Active or deactivated, both work. ### Steps to convert Done. If the member was still active, Tallyfy deactivates their account for you during the conversion. ### What happens after conversion The change takes effect immediately: - 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 [guest links](/products/pro/documenting/guests/how-to-find-a-guest-task-link-in-tallyfy/) sent by email. - They're removed from any groups and lose their member permissions. - You free up a paid member seat. Their open tasks stay assigned to them - converting doesn't reassign work. If someone else should take over, reassign those tasks yourself. You can do it before or after the conversion. ### When conversion is blocked Tallyfy rejects the conversion and changes nothing in these cases: - **The only administrator** can't be converted. Your organization always needs at least one admin. - **Trial plans at the guest limit** can't add the new guest. Remove an unused guest or upgrade first. - **[Remove a member](https://tallyfy.com/products/pro/documenting/members/how-can-i-remove-a-member-from-my-tallyfy-organization/)**: Admins can remove a member by deactivating their account under Settings > Organization > Members. You'll then choose to reassign open tasks to other team members or leave them unassigned. ## Removing members from your organization To remove a member from Tallyfy, go to **Settings** > **Organization** > **Members**, click their name, and select **Deactivate Account** at the bottom of their profile. Access is revoked 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 1. Go to **Settings** > **Organization** > **Members**. 2. Click the member's name. 3. Scroll to the bottom of their profile page. 4. Click **Deactivate Account**. ![Deactivate account button on member profile](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-remove-member.png) Deactivation happens instantly. ### Choosing what happens to their tasks When you deactivate a [member](/products/pro/documenting/members/), you'll decide what happens to their current [tasks](/products/pro/tracking-and-tasks/tasks/). Two options: 1. **Reassign their tasks** (recommended): - Pick other active members to take over the work - Tallyfy prompts you for their pending tasks and their [template](/products/pro/documenting/templates/) steps ![Task reassignment conflict resolution dialog](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-conflict-resolution-example.png) 2. **Skip the reassignment**: - Select **Deactivate without reassigning their tasks** - Their tasks stay owned by the deactivated member, even though that person can't sign in any more. Nothing becomes unassigned and nothing moves to anyone else, so reassign the work yourself when you're ready ### What happens after deactivation - They lose access to your Tallyfy organization immediately - Their paid seat[^1] opens up for new team members - Tallyfy records who performed the deactivation and when (visible in the member's Activity section) :::warning[Check public kick-off forms first] Before deactivating anyone, check if they're the inviter or creator for any [templates](/products/pro/documenting/templates/) used in public [kick-off forms](/products/pro/launching/triggers/kick-off-forms/)[^2]. - **Member was the *inviter* (but didn't create the template)** - Tallyfy automatically switches the inviter to the template creator. Public sharing stays ON. - **Member was the *creator* of the template** - Tallyfy may turn OFF public sharing for that form, breaking the public link immediately. An Administrator would need to turn public sharing back ON and pick a new member to associate with the form. ::: ### Checking deactivation history 1. Go to **Settings** > **Organization** > **Members** 2. Find the deactivated member's name (you may need to filter the list) 3. Check the **Activity** section at the bottom of their profile page The activity log shows who deactivated the member and when. [^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. - **[Resend or withdraw invites](https://tallyfy.com/products/pro/documenting/members/how-to-resend-or-withdraw-invites-in-tallyfy/)**: Tallyfy lets administrators resend or withdraw pending member invitations from Organization Members settings. Handle expired links, wrong email addresses, or free up seats when plans change. ## Managing pending member invitations You can resend or withdraw pending invites from your Organization Members settings - whether someone's email got lost in spam or you 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 - The person never received your email - The invitation link expired - They deleted the email by accident - It's stuck in their spam folder ### When to withdraw (cancel) an invitation - You typed the wrong email address - Plans changed and they're not joining - You need to reinvite them with different permissions - You need that paid [member](/products/pro/documenting/members/) seat for someone else ### How to resend or withdraw an invitation ### What happens after each action **After resending:** - They'll get a new invitation email with a fresh link - The old invitation link stops working - This doesn't use another [member](/products/pro/documenting/members/) seat - it updates the existing invite **After withdrawing:** - The invitation link dies instantly - The [member](/products/pro/documenting/members/) seat opens up for someone else - Tallyfy removes the invitation from your pending list - If that person doesn't belong to any other Tallyfy organization, Tallyfy also removes their user record - **[Invite and activate members](https://tallyfy.com/products/pro/documenting/members/how-to-invite-and-activate-members-on-tallyfy/)**: Admins (and optionally Standard members) can invite new users by clicking Invite+ and entering an email with a name and role. Invitees receive an email to activate their account and join the organization. ## Inviting members and managing activation Click the **Invite+** button anywhere in Tallyfy, enter an email address, and that person gets an invitation to set up their account. ### What you'll need - Administrator permissions by default (admins can also allow Standard members to invite others via org settings) - An available paid [member](/products/pro/documenting/members/) seat in your plan - The email addresses of people you're inviting ### Inviting new members ### Invites hold a seat straight away An invitation reserves its seat the moment you send it, not when the person accepts. That's deliberate. It means the seat is guaranteed to be there when they arrive, and it means you find out you're short a seat while you're still on the invite screen, rather than days later when someone can't sign in. Two consequences worth knowing: * **If the pool is already full, the invitation itself is refused** and Tallyfy offers to sell you the seat there and then. Buy it from that prompt and the invite goes out. * **A pool can read as full because of invites nobody has accepted.** Invitations don't expire, so they hold their seats until someone accepts or an administrator revokes them. Revoking a pending invite frees its seat immediately, which is the quickest way to recover a seat you need right now. The role you pick decides which pool the seat comes from: Administrator and Standard draw a **full** seat, Light draws a **light** seat. [Guests](/products/pro/documenting/guests/) are free and unlimited and never touch either pool. :::note Non-admin members can't assign the Administrator role when inviting someone. Only admins can grant admin access. ::: ### Managing sent invitations Go to **Settings** > **Organization** > **Members** and look for anyone with "Invited" status - that's everyone who hasn't joined yet. You can resend an invitation right from that page. Invited the wrong person? Click **Withdraw** to cancel it. :::tip[Troubleshooting invitation delivery] **Invitations not arriving?** Common fixes: 1. **Check spam/junk folders** - Search for emails from tallyfy.com 2. **Verify the email address** - Even small typos prevent delivery 3. **Whitelist Tallyfy** - Add tallyfy.com to allowed senders 4. **Corporate firewalls** - IT may need to allow emails from noreply@tallyfy.com 5. **Resend after 24 hours** - Email servers sometimes have temporary issues 6. **Check invitation status** - **Settings** > **Organization** > **Members** shows if the invite is still pending Still stuck? Contact support with the exact email address. ::: ### The activation process Here's what your new team member does after receiving the invite: ### Verifying someone joined - **[Light members](https://tallyfy.com/products/pro/documenting/members/light-members/)**: Light members are task-focused users like field workers and contractors who can log in and complete assigned work but can't create or edit templates. Administrators can grant them launch permission for specific templates. ## What Light members can do Light members complete assigned work in Tallyfy but can't create or edit templates. They're built for people who do tasks, not design workflows. :::note[Light user availability] **Introduced**: October 2024 **Requirements**: - Organizations with Single Sign-On (SSO) configured, OR - Manually enabled by Tallyfy support for specific orgs Light users solve the SSO problem where company email addresses can't be added as [guests](/products/pro/documenting/guests/). The role sits between guests and full members. ::: ### Capabilities - **Tasks** - Complete assigned [tasks](/products/pro/tracking-and-tasks/tasks/), view details and attached files, add comments, upload files, mark tasks complete or incomplete - **Processes** - Access [processes](/products/pro/tracking-and-tasks/processes/) where they're assigned, view the process flow for those processes, see upcoming tasks on the dashboard - **Account** - Log in with their own credentials, update their profile, view guests they're collaborating with :::note[Template visibility for Light members] Light members only see templates when an Administrator grants them LAUNCH permission. They still can't edit or create templates - just launch processes from them. Light members also work well with [knowledge-only mode](/products/pro/tutorials/knowledge-only-mode/). They can view procedures and reference SOPs without launching formal processes. ::: :::tip[Light members vs guests] Light members are users within your organization with their own login. [Guests](/products/pro/documenting/guests/) are external email addresses (customers, vendors) who only access specific tasks via email links. ::: ### What Light members can't do - **Templates** - Can't create, edit, clone, organize into folders, import, or export [templates](/products/pro/documenting/templates/) - **Process control** - Can't delete running processes, change process settings, reassign tasks, or manage automated actions - **Admin functions** - Can't invite members, access org settings, view API keys, or manage permissions for others ### Launching processes By default, Light members can't launch processes. But Administrators can grant LAUNCH permission for specific templates: 1. Open the template's **Config** settings 2. Find the Light member who needs launch access 3. Grant them **LAUNCH** permission for that template 4. The template appears in the Light member's library with a launch button Light members launch the process without seeing or editing the template design. **Good use cases for Light member launching:** - Warehouse staff starting morning safety inspections - Receptionists launching client onboarding - Field workers initiating incident reports - Production line workers starting quality checks :::tip[Organize for Light members] Create template folders named clearly like "Daily Operations - Light Users". This helps Light members find launchable processes without clutter. ::: ### When to use Light members **Field and frontline workers** - delivery drivers, technicians, construction crews, healthcare workers **Contractors and partners** - vendors completing quality checks, temporary staff, project-based contractors **Task-focused internal roles** - data entry, warehouse staff, customer service reps, reception desk **Knowledge base users** - teams referencing [knowledge-only procedures](/products/pro/tutorials/knowledge-only-mode/) and SOPs without formal task tracking ### Role planning 1. **Audit Full members** - find people who only complete tasks, never create templates 2. **Convert task-only users** to Light member status 3. **Reserve Full member licenses** for process designers and managers 4. **Monitor usage** - track who actually creates templates versus who just executes :::tip[Role planning example] A 100-person company with 20 process designers and 80 field workers? Keep 20 Full member licenses for designers. Convert the 80 field workers to Light members. ::: ### Upgrading to a Full member [Changing roles](/products/pro/documenting/members/how-can-i-change-a-members-role-in-tallyfy/) takes seconds: 1. Go to **Settings** > **Organization** > **Members** 2. Find the Light member 3. Click their role dropdown and select **Standard** or **Administrator** 4. Changes take effect immediately - no logout needed The member keeps all task history and active assignments. ### Best practices - **Write clear task instructions** - Light members can't edit templates, so descriptions need to be thorough with step-by-step guidance - **Think mobile-first** - many Light members work from phones, so keep descriptions short and forms simple - **Grant LAUNCH only where needed** - keep the interface focused on what each Light member actually does - **Training is minimal** - show them how to log in, find tasks, and complete them. That's it. - **[Standard and admin members](https://tallyfy.com/products/pro/documenting/members/standard-admin-members/)**: Tallyfy has three member roles. Administrators get full account control, Standard members create templates and run processes with Admin-granted permissions, and Light members can only complete assigned tasks at lower cost. ## Administrator vs Standard member roles Tallyfy has two main paid [member roles](/products/pro/documenting/members/) - Administrator and Standard. There's also a Light role, covered below. ### Full vs Light members **Full members** (Administrator and Standard) can create templates and run tasks. **Light members** can only complete assigned tasks - they can't create or edit templates. :::tip[Save on member costs] Light members cost less than Full members. Give Light licenses to people who only complete tasks (warehouse staff, field workers, contractors). Save Full licenses for process designers and managers who create workflows. See our [pricing page](https://tallyfy.com/pricing/) for current rates. ::: ### Administrator role Administrators control everything in your Tallyfy account. #### What Administrators can do - **Account settings:** - Change [billing](/products/pro/settings/billing/) and subscription plans - Update [organization details](/products/pro/settings/org-settings/how-can-i-update-my-organization-details/) - Set up custom SMTP for organization emails - Manage organization logo and custom branding - Configure SAML/SSO settings[^1] (with Tallyfy 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/) - Set permissions for Standard members - Edit member profiles and remove members - View activity history - **Process control:** - Create, edit, and view all [templates](/products/pro/documenting/templates/) - Control access to specific templates and running [processes](/products/pro/tracking-and-tasks/processes/) - Permanently delete templates and processes (not just archive) - Pin templates for organization-wide visibility #### How to find Administrators 1. Go to **Settings** > **Organization** > **Members** 2. Look for the **Administrator** role label ### Standard role Standard members have limited permissions focused on daily work, not account management. #### What Standard members can do (if allowed by an Admin) Standard members can do a lot, but only with Administrator-granted permissions: - **Templates:** - Create, edit, and view [templates](/products/pro/documenting/templates/) they've been given access to - Launch processes from templates (requires LAUNCH permission) - Organize templates into folders - Import templates from other sources :::note[Template visibility and permissions] Templates appear in the library for Standard and Light members unless **ALL THREE** permissions (EDIT, READ, and LAUNCH) are removed. To hide a template completely, remove all three. New templates don't automatically grant Standard members any permissions. Administrators must explicitly grant EDIT, READ, and/or LAUNCH access. ::: - **Collaboration:** - [Invite](/products/pro/documenting/members/how-to-invite-and-activate-members-on-tallyfy/) other Standard or Light members (if allowed by Admin - can't assign the Admin role) - View the member and [guest](/products/pro/documenting/guests/) list - Access shared tags and text [snippets](/products/pro/documenting/templates/snippets/) - View [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 - Create and manage groups (if the Administrator enables this) #### What Standard members can't do - Permanently delete templates or processes (archiving/soft delete[^2] only) - Pin templates for organization-wide visibility - Access member profiles or organization settings - Configure SMTP, SAML, or custom branding - Change billing or subscription plans ### When to use each role **Administrator** - executives, IT admins managing integrations and security, operations managers overseeing all workflows, HR leaders managing user access. **Standard (Full member)** - department heads creating team workflows, process improvement specialists, team leads launching and tracking processes, QA staff refining procedures. **Light member** - field technicians working through checklists, warehouse staff, customer service reps following scripts, external contractors, part-time employees. :::note[Light member limitations] Light members see templates only when an Administrator grants LAUNCH permission. They can't create, edit, or organize templates. This focused access makes them ideal for task execution roles at a lower cost. ::: [^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 ### Templates - **[Auto-recording steps for SOPs](https://tallyfy.com/products/pro/documenting/templates/auto-recording-steps-for-sops/)**: Free screen capture tools like ShareX and OBS Studio let you document procedures in Tallyfy without paying for proprietary tools. Unlike Scribe or Trainual, which only capture steps, Tallyfy also tracks execution and automates workflows. ## Capturing procedures without expensive recording tools You don't need paid tools like Scribe, Trainual, or iorad to document procedures. Free screen capture tools plus Tallyfy's rich text editor cover everything you need for step-by-step instructions. The real value isn't capturing steps - it's tracking completion, automating workflows, and making sure procedures actually get followed. ### Why paid capture tools aren't necessary Tools like Scribe, Trainual, or iorad lock your content into proprietary formats. You're stuck paying monthly fees just to access your own procedures. Worse, 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 Tallyfy handles 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) - Screenshot and recording tool with auto-upload - Capture screenshots with annotations - Auto-upload to Imgur for instant URLs - Record GIFs for short step demos - 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 compress 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 ### 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) 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. Use the image button in the toolbar to add the screenshot 5. Choose upload (for local files) or URL (for hosted images) ### Method 2: Video walkthroughs 1. Record using OBS, Kap, or built-in tools 2. Upload to YouTube/Vimeo as unlisted 3. In Tallyfy's editor, use the video or embed button in the toolbar 4. Paste the video URL 5. Add text descriptions for key steps below Videos work well for UI procedures where motion helps explain the flow. ### Method 3: Animated GIF loops 1. Use ScreenToGif (Windows) or Kap (Mac) to record 3-10 second loops 2. Export as a compressed 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 1. Host the HTML on your web server 2. Use the embed button in Tallyfy's toolbar to embed the content 3. Or copy text from HTML and 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/) Tallyfy strips most HTML formatting when pasting to maintain consistency. ## What makes Tallyfy different ### Beyond documentation - actual execution Capture tools stop at documentation. Tallyfy makes sure 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 for quality control ### Real examples **Employee onboarding** - Scribe/Trainual: Static checklist with screenshots - Tallyfy: Auto-assigns IT setup to tech team, schedules training by 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 ## 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 - Keep original screenshots in cloud storage - Save screen recordings as standard MP4 files - Store text instructions in documents you own - Use open formats (HTML, Markdown) when possible This way you can switch 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. **Add 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 in Tallyfy: - **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 ### Keeping file sizes small 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 - Capture at the 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 the starting point. Tallyfy handles what 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/) - **[Configure your template](https://tallyfy.com/products/pro/documenting/templates/config/)**: Tallyfy's template settings let you control duplicating, archiving, summary details, permissions, and export IDs. Organize and restrict who can view or launch processes from any template. ## Template settings Click **Settings** (or **Config**) when editing a template in Tallyfy to control how it 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 given edit permission on the template, can change these settings. Light members can't edit templates. ::: ### General settings ![Template general settings panel in Tallyfy](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-configure-template-general-settings.png) #### Duplicate a template Creates an exact copy of your template. The copy won't affect the original. Give it a new name, or it'll default to "COPY OF - [original template name]". ![Template duplication dialog in Tallyfy](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-configure-template-duplicate.png) :::note[What gets copied] Duplication copies steps, webhooks, and tags (within the same organization). If you duplicate across organizations, tags are recreated by name. ::: #### Archive a template Archiving soft-deletes the template from your library. It's not permanently removed - you can restore it later. #### Print a template Creates a printable version you can save as PDF. See [Print, Download, and Export Templates](/products/pro/documenting/templates/print-download-export-templates/). ![Template print option in Tallyfy](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-configure-template-print.png) #### Organize templates into folders Move templates into folders to keep your library tidy. See [Organize Templates into Folders](/products/pro/documenting/templates/organize-templates-into-folders/). ![Template folder selection in Tallyfy](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-configure-template-folder.png) ### Summary settings ![Template summary settings panel in Tallyfy](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-configure-template-summary.png) * **Description**: Explain what the template is for. * **Status**: Set "Published", "In Progress", etc. This shows in the main Templates view. * **Internal explanation video URL**: Paste a video link. A video icon then appears next to the template for others to click. * **General information**: Shows the creator, last updated date, and other metadata. * **Force launcher to folderize [process](/products/pro/tracking-and-tasks/processes/)?**: Requires users to pick or create a folder *before* launching a process. You can also set a default folder. * **Force launcher to tag process?**: Requires users to add at least one tag *before* launching. Helps categorize running processes. * **Original document**: Upload the source file (Word doc, PDF, etc.) this template was based on. * **Template tags**: Add tags to organize your templates. * **Special instructions**: Notes shown right before someone [launches](/products/pro/launching/) a process. Use for key reminders. * **Webhook settings**: Send automatic notifications to other apps when tasks complete. :::note[What are webhooks?] [Webhooks](/products/pro/integrations/webhooks/) let Tallyfy send data to other web apps when something happens - like a task being completed. ::: ### Track template activity The Activity tab logs every template change - who made it and when. ![Template activity log in Tallyfy](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-configure-template-activity.png) ### Control template permissions ![Template permissions settings in Tallyfy](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-configure-template-permissions.png) :::note[Important: Template visibility] To completely hide a template from Standard and Light users, you must restrict **all five** permission types. If any permission is allowed, the template still appears in their view. ::: #### Make a template publicly visible You can make templates public so anyone can find them in the [public library](/products/pro/documenting/templates/how-to-make-my-tallyfy-template-public/). #### Set template permissions Control who can interact with this template. You can allow everyone or pick specific people or groups. **Five permission types:** - **EDIT**: Modify the template - **READ**: View template details - **LAUNCH**: Start new processes from the template - **DUPLICATE**: Copy the template - **PROCESS READ**: View running processes created from the template #### Configure one-off task settings Decide if people can add unplanned [tasks](/products/pro/tracking-and-tasks/tasks/) to running processes. Look for **"Can people add one-off tasks to this process?"** - **Yes (default)**: Anyone involved can add extra tasks. - **No**: Nobody can add extra tasks - the process strictly follows defined steps only. Set this to **No** for compliance or safety procedures that must follow exact steps. ### Export options This section shows IDs you'll need for integrations or support. ![Template export options showing org and template IDs](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-configure-template-tools.png) * **Org ID**: Your organization's unique identifier. * **Template ID**: This template's unique identifier. You'll need these when: * Contacting Tallyfy support * Setting up [integrations](/products/pro/integrations/) with other tools * Copying this template to another organization via [Template Importing](/products/pro/documenting/templates/import-feature/) - **[Create templates](https://tallyfy.com/products/pro/documenting/templates/create-template/)**: Tallyfy lets you create reusable process templates three ways. Build from scratch, generate with AI from a description or uploaded Word/PDF document, or use exact HTML import for compliance-critical SOPs that must preserve every word. ## Creating templates in Tallyfy Click **+Create** and choose from three options: start from scratch, use Tallyfy AI, or upload an existing document. Templates are reusable blueprints you build once, then launch as many times as you need. Only "Administrator" members and "Standard" members (when allowed by an Admin) can create templates. [Members](/products/pro/documenting/members/) with a "Light" role can only run processes from existing templates. ### From scratch Choose this when your process is unique or needs precise control over every step, field, and automation rule. ![Create template from scratch dialog in Tallyfy](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-create-template-scratch.png) ### Using Tallyfy AI Describe your process and Tallyfy AI generates a working template in seconds. The AI doesn't just copy your input - it rephrases confusing steps, removes redundancy, and restructures everything for digital execution. The more specific your description, the better. Instead of "employee onboarding," try "onboard a remote software developer including laptop setup, account access, and first-week training." ### Uploading documents Got a Word doc or PDF with your process already written out? Upload it and Tallyfy AI transforms it into a trackable workflow. The AI reads your document, then rebuilds it for digital execution - cleaning up redundancies and restructuring for clarity. Supported file types: - Microsoft Word (`.doc`, `.docx`) - PDF (`.pdf`) ### Exact import for compliance Sometimes you need every word exactly as written - no AI interpretation. Think compliance docs, legal requirements, audited SOPs. There's no one-click "exact import" button, but here's the workaround: convert your document to clean HTML first, then paste it into Tallyfy. **Why use exact import?** - **Compliance** - your Tallyfy template matches your approved source document character for character - **Legal requirements** - preserves exact wording and structure regulations demand - **Preservation** - creates a digital twin with no AI rewording **Video demonstration:** ## Next steps Learn how to [edit and customize your template](/products/pro/documenting/templates/edit-templates/) - add steps, set up automation rules, create form fields. You can also [organize templates into folders](/products/pro/documenting/templates/organize-templates-into-folders/) to keep things tidy. - **[Track activity](https://tallyfy.com/products/pro/documenting/templates/how-can-i-track-activities-on-my-tallyfy-templates/)**: Tallyfy's Activity tab shows who changed what and when on any template. Every content edit, configuration update, and form field change gets recorded with timestamps in your local timezone. ## Tracking template activities and changes Click the **Activity** tab when viewing any template in Tallyfy to see a full history of who changed what and when. Every modification - from title edits to automation updates - gets recorded automatically. ### Who can view template activity logs? Tallyfy restricts activity log access to: - Administrators - Standard members with read or edit permission on that template - The template creator ### Why activity tracking matters Think someone accidentally broke your workflow? The activity log shows exactly when things changed. - **Change history** - every modification gets recorded, perfect for audits - **Accountability** - you'll know exactly who made each change - **Troubleshooting** - check when the last changes were made and undo if needed - **Compliance** - prove how your processes are controlled and who's responsible ### What gets tracked? Tallyfy records four main categories of template changes: #### Content changes - Template title and summary updates - Step creation, deletion, and reordering - Step descriptions, deadlines, and assignee changes - Guidance text added, updated, or removed #### Form field updates - Kick-off form field descriptions added or changed - Form field values added or updated #### Configuration changes - Tags added or removed - Permission changes - Webhook updates on steps - Automation rules created, updated, or deleted - Template archiving and unarchiving - Folder assignment changes #### Other tracked actions - Template creation and deletion - Auto-naming configuration changes - Owner changes ### How to check the activity log 1. Go to your **Templates** library 2. Open the template you want to check 3. Click **View** 4. Select the **Activity** tab ![Tallyfy template Activity tab showing 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. Each entry shows: - **When** - exact date and time - **Who** - which team member made the change - **What** - the type of change (created, updated, deleted, archived, etc.) - **Details** - what specifically was modified For example: "March 15, 2025 at 2:47 PM - Sarah Johnson - Step Deadline Updated - Changed 'Review proposal' deadline from 2 days to 3 days." :::note[Activity timestamp display] Timestamps are stored in ISO 8601 format[^1]. Tallyfy displays them in your personal timezone setting, so you'll always see accurate local times. ::: ### How long do logs last? Activity logs persist as long as the template exists. Archive a template? The history stays intact. Copied templates start fresh with a blank activity log - they're treated as new templates. You can't edit or delete log entries. This keeps the audit trail[^2] trustworthy. ### Access control Activity logs are only visible to administrators, members with template read/edit permissions, and the template creator. [^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 - **[Sample templates](https://tallyfy.com/products/pro/documenting/templates/how-can-i-access-tallyfys-sample-templates/)**: Tallyfy's public template library offers ready-made workflow blueprints across departments like HR, sales, and marketing. You can import them in one click and customize with your own steps, assignments, and deadlines before launching. ## Using Tallyfy's sample templates Import ready-made templates from Tallyfy's public library in a few clicks. They cover everything from employee onboarding to sales processes. Instead of starting from a blank template, you'll get proven workflows to customize for your team. ### Why use sample templates - **Faster setup** - launch your first process in minutes, not hours - **Learn by example** - see how successful companies structure their workflows - **Stay consistent** - every department uses the same proven process structure ### Finding sample templates Visit [Tallyfy's Public Library](https://go.tallyfy.com/public/library) to browse templates. You can filter by type, industry, and topic. Preview any template before importing, then import it to your account with one click. ### 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 tracking new ideas - 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 ### Customizing sample templates After importing a template, make it yours: ### Organizing imported templates - Create folders by department or process type - Name templates clearly - "Employee Onboarding v2" beats "HR Process 3" - Tag templates so they're easy to find later - Document major changes with notes like "Added legal review step for California compliance" - **[Template tools](https://tallyfy.com/products/pro/documenting/templates/how-can-power-tools-enhance-my-tallyfy-experience/)**: Tallyfy's Template Tools let you bulk-create steps by pasting a list and bulk-assign people or adjust deadlines across many steps at once instead of editing each one individually. Administrators can also push templates into other users' favorites for quick access. ## Template tools Template Tools let you change multiple parts of a template at once - bulk-create steps, assign people, adjust deadlines, and manage favorites. There's no need to click through each step individually. ### Requirements - Edit access to the template - Standard role with edit permission, or Administrator role ### Accessing Template Tools 1. Open a [template](/products/pro/documenting/templates/) in edit mode. 2. Click **Tools** in the toolbar at the top of the editor. 3. The Tools modal opens with tabs: **Build Steps**, **Assign**, **Deadlines**, and (for Administrators) **Favorites**. ### Bulk step creation Add many steps at once instead of creating them one by one. - **Copy/paste friendly** - got your process in a Word doc? Paste the whole list - **Fast** - go from blank template to fully structured in minutes #### How to bulk-create steps 1. Open the **Build Steps** tab in Template Tools. 2. Type or paste your step names into the text box. Put each step name on its own line. 3. Click **BUILD**. Tallyfy adds all steps to your [template](/products/pro/documenting/templates/) in the order you listed them. ![Tallyfy Template Tools build steps interface](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-click-powertools-create-steps.png) ### Batch assignment Assign (or unassign) one person or group to many steps at once. - **Consistency** - when the finance team owns all budget approvals, they actually get assigned to all of them - **Fewer mistakes** - you can't forget step 17 when you're assigning in bulk #### How to batch-assign 1. Open the **Assign** tab in Template Tools. 2. Choose the person or group ([assignee](/products/pro/documenting/members/)) from the dropdown. 3. Toggle **Assign** or **Unassign** on each step you want to change. 4. Click **APPLY** to save. ![Tallyfy Template Tools batch assignment interface](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-click-powertools-assign.png) ### Bulk deadline adjustment Adjust deadlines across multiple steps without editing each one. - **Quick updates** - contract terms changed? Adjust every deadline in seconds - **Consistent SLAs** - set the same timing across all review steps at once #### How to adjust deadlines in bulk 1. Open the **Deadlines** tab in Template Tools. 2. For each step, use the increment (+) and decrement (-) buttons to adjust the deadline value. 3. Choose the time unit per step (minutes, hours, days, weeks, months)[^1]. 4. Click **UPDATE**. *Note: For templates, deadlines are relative to when the process is [launched](/products/pro/launching/). You can't set deadlines based on when other steps complete.* ![Tallyfy Template Tools deadline adjustment interface](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-click-powertools-deadlines.png) ### Template favoriting (Administrators only) Add a template to other users' favorites so they can find and use it quickly. - **Visibility** - put the right templates front and center for your team - **New hires** - day one, they've got essential processes starred and ready - **Notifications** - watchers get notified when a favorited template is updated[^2] #### How to favorite a template for others 1. Open the **Favorites** tab in Template Tools (visible only to Administrators). 2. Search for and select the team [members](/products/pro/documenting/members/) you want to add this template as a favorite for. 3. Click **Favorites** to save. 4. The [template](/products/pro/documenting/templates/) appears in those users' Favorites section. *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/).* ![Tallyfy Template Tools favorites interface](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-click-powertools-favorite.png) ### Tips - Double-check your work after bulk changes - Use bulk step creation when building templates with 10+ steps - Use batch assignment for role-based workflows where one person handles multiple steps - Adjust deadlines in bulk when timing requirements change [^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 - **[Convert BPMN into templates](https://tallyfy.com/products/pro/documenting/templates/how-to-convert-bpmn-patterns-into-tallyfy-templates/)**: Tallyfy turns static BPMN diagrams into real running workflows by mapping standard patterns like sequential flows, gateways, and loops to simple automation rules and steps anyone on your team can build and launch without technical training. ## Converting BPMN patterns to Tallyfy Recreate your BPMN (Business Process Model and Notation) diagrams as runnable Tallyfy templates using the step-by-step builder. No technical expertise needed. Your templates become real workflows that your team can launch, track, and complete. ### Why BPMN diagrams fall short - **Complex symbolism** - diamonds, circles, and gateways require training just to read - **Static documentation** - diagrams can't actually run anything - **Technical barriers** - non-technical teams can't interpret BPMN notation - **Modification friction** - changing a single step often requires IT involvement - **Implementation gap** - diagrams rarely match how people actually work ### Why Tallyfy works better - **Runnable processes** - templates become real workflows you can launch and track - **No coding needed** - if you can fill out a form, you can build a process - **Anyone can use it** - from interns to executives, the interface is self-explanatory - **Live updates** - change a step and it's live immediately - **Built-in tracking** - see exactly where every process stands in real time ### BPMN pattern equivalents in Tallyfy Every standard BPMN pattern maps to a Tallyfy feature: | BPMN pattern | How Tallyfy handles it | |-------------------------------|---------------------------------------------| | Sequential Flow | Steps run one after another - use automation rules to enforce order | | Parallel Split (AND) | Multiple steps are active at the same time (default behavior) | | Exclusive Gateway (XOR)[^1] | Automation rules show/hide steps so only one path runs | | Inclusive Gateway (OR)[^2] | Automation rules show/hide steps so multiple paths can run | | Synchronization | Automation rules wait for multiple steps to complete before triggering | | Structured Loop | Reopen action lets you repeat steps within a process | | Deferred Choice | Automation rules conditionally assign tasks to different people | ### Resources for BPMN conversion For detailed walkthroughs of each pattern with real examples: [BPMN Examples and Patterns in Tallyfy](https://tallyfy.com/bpmn-examples-and-patterns) ### Steps for converting BPMN to Tallyfy 1. **Study your BPMN diagram** - identify the main steps, decision points, and responsibilities (10-15 minutes for most diagrams) 2. **Map the core logic** - note what happens in sequence and where paths split 3. **Create a new template** in Tallyfy 4. **Build your workflow** - add steps, assign them to the right people, and set up automation rules 5. **Add the details** - add [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 to catch issues 7. **Go live** - [launch](/products/pro/launching/) the real process [^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 - **[Duplicate a template](https://tallyfy.com/products/pro/documenting/templates/how-do-i-duplicate-a-template-on-tallyfy/)**: Duplicate a template in Tallyfy through the More menu to copy all steps, form fields, automations, tags, and webhooks while generating fresh IDs for every field and step. ## Duplicating templates Click the **More** menu (three dots) on any template card and select **Duplicate**. You'll get a copy of your [template](/products/pro/documenting/templates/) - perfect for creating a variant of a [process](/products/pro/tracking-and-tasks/processes/) or testing changes without touching the original. The copy's title is automatically prefixed with "COPY OF -". :::note[Who can duplicate templates?] [Members](/products/pro/documenting/members/) with a "Light" role can't duplicate templates. Only "Standard" members (if an Admin allows them) or "Administrator" members can. ::: ### Why duplicate? - **Save time** - skip rebuilding similar templates from scratch - **Keep consistency** - start with the same foundation, then tweak for specific needs - **Create versions** - different teams often need their own variant (e.g. Sales vs. Marketing onboarding) - **Test safely** - experiment on the copy while the original stays untouched ### How to duplicate ### What gets copied Almost everything carries over: - All steps in the same order - [Task](/products/pro/tracking-and-tasks/tasks/) descriptions and instructions - All [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) and their settings - Conditional logic (rules)[^2] and [automations](/products/pro/documenting/templates/automations/) - Task assignments, group assignments, and guest assignments (within the same organization) - Step dependencies and deadlines - Tags and [webhooks](/products/pro/integrations/webhooks/) - The template description ### What gets new values A few things reset on your copy: - **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** - the copy starts with no activity logs - **Template ID** - the copy gets its own unique ID in Tallyfy ### After duplicating [^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 - **[Publish a template](https://tallyfy.com/products/pro/documenting/templates/how-to-make-my-tallyfy-template-public/)**: Tallyfy lets you publish any template publicly by toggling a single setting. Anyone with the link can view your process structure and steps without needing an account, while all run data and form responses stay private. ## 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**. Anyone can then view your template structure[^1] without logging in. You'll get a shareable link to send to clients, partners, or vendors. ### What you need - Administrator or Standard member permissions (Light members can't edit templates) - A template ready for public sharing ### Why publish a template? - **Share with anyone** - give a direct link to view your process. No login or Tallyfy account needed - **Show examples** - display your workflows to potential customers as proof of how you work - **Provide documentation** - external teams can access process info instantly - **Help others learn** - let people see how you've structured your processes ### Publishing a template ![Public to the world setting in Tallyfy template settings](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-public-template.png) ### After publishing You'll get a shareable URL in the template settings. You can: - Share this link anywhere - email, chat, website, social media - Let people view the template structure without logging in ### Security and privacy - **What's public?** Only the template structure - steps, descriptions, summary, guidance, and kickoff fields. Think of it like sharing a recipe without showing what you cooked last Tuesday - **What's private?** Form field responses, task completions, internal comments, and assignment data don't show up publicly - **How to unpublish?** Go back to settings, switch **Public to the world** to **no**, and it's instantly private again [^1]: In Tallyfy's API, templates are called 'blueprints' and include steps, fields, and routing logic - **[Tags](https://tallyfy.com/products/pro/documenting/templates/how-to-manage-templates-and-processes-with-tags/)**: Tags in Tallyfy are color-coded keywords you attach to templates and running processes. They let you organize and filter items across multiple categories without being limited to a single-folder structure. ## Using tags for organization Tags in Tallyfy are keywords you attach to [templates](/products/pro/documenting/templates/) and running [processes](/products/pro/tracking-and-tasks/processes/). Unlike folders, you can add multiple tags to the same item. A single template can be tagged "HR", "Onboarding", and "High Priority" all at once. :::note[Who can manage tags?] "Light" [members](/products/pro/documenting/members/) can't add tags to templates. "Standard" members can add tags to templates they have edit access to. Only "Administrators" can create, edit, or delete the shared tag list[^1] for the whole organization. ::: ### Requirements - Administrator permission to create, edit, or delete the organization's tag list - Edit permission on a template or process to add tags to it ### Benefits of using tags - **Find things faster** - search by specific tags in seconds - **Organize flexibly** - group items in multiple ways without folder limitations - **See labels easily** - color-coded tags make identification instant - **Filter lists** - combine tags to narrow down your [Tracker](/products/pro/tracking-and-tasks/tracker-view/) view - **Group related processes** - see all "Client Project" processes even if they span different folders ### Managing the organization's tag list (admins only) Administrators control which tags everyone can use. Tag names can't exceed 30 characters and must be unique within your organization. ### Adding tags to templates ### Adding tags to running processes ### Filtering by tags ### Tips for effective tag usage - **Use consistent names** - pick standard names (e.g., always "Human Resources" instead of sometimes "HR") - **Keep it simple** - stick to around 10-15 main tags so the list stays manageable - **Group logically** - create tags for categories like: - Department (HR, Finance, Sales) - Type of work (Approval, Review, Onboarding) - Priority (High, Medium, Low) - **Use with folders** - folders for main structure, tags for cross-cutting labels - **Clean up regularly** - review your tag list in Settings and delete unused tags [^1]: Tags are organization-wide and synchronized across all users, unlike personal labels in some systems - **[Acknowledgement of changes](https://tallyfy.com/products/pro/documenting/templates/how-to-request-bulk-acknowledgement-for-template/)**: Tallyfy lets you request bulk acknowledgement of any document or procedure by creating a one-off task linked to a template and assigning it to your entire team with the "all assignees must complete" setting turned on so every person gets their own tracked instance they must individually finish by the deadline. 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. This works for both [document templates](/products/pro/documenting/documents/) and [procedure templates](/products/pro/documenting/templates/). ## Requirements You'll need: - An existing [document template](/products/pro/documenting/documents/) or [procedure template](/products/pro/documenting/templates/) - Permission to create and assign tasks - typically an Administrator or Standard user[^1] ## Requesting bulk acknowledgement ## The "all assignees must complete" setting When you assign a task to 50 people with this option on, all 50 must mark their individual task as complete before Tallyfy considers it done. - Each person gets their own instance of the task - they can't complete it for someone else - Progress is tracked in real-time - Ideal for compliance audits, safety procedures, and policy updates where you need confirmation from everyone For more on task settings, see the [advanced task options guide](/products/pro/tracking-and-tasks/tasks/how-can-i-utilize-tallyfys-advanced-tab-features/). [^1]: Standard users can create, edit and complete tasks but can't 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/)**: Import templates into Tallyfy from Word docs, PDFs, PowerPoint files, flowchart images, or other Tallyfy accounts. AI converts even 50-page SOPs into working templates in seconds, replacing duplicate files with one dynamic template. ## Import options for templates Import templates into Tallyfy from Word docs, PowerPoint files, flowchart images, or other Tallyfy accounts. Minutes, not hours. :::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 can't. ::: ### AI document conversion Upload a Word doc or PDF, and Tallyfy's AI converts it into a working template. A 50-page SOP? Ready in seconds. - Upload your file (Word or PDF) - The AI reads through the content - Choose your output: - **Document**: Creates a Tallyfy document with proper formatting - **Procedure**: Builds a step-by-step process template - Review the result and tweak as needed **Time savings**: Converting a 35-slide PowerPoint takes roughly 10 seconds via AI import vs. 2+ hours of manual copy-paste. Convert the file to PDF first. :::note[Non-exact import (default)] This AI conversion is **non-exact**. The AI may modify content, formatting, or structure to create a better Tallyfy template. It prioritizes a functional process over an exact replica of your source file. For verbatim copies (e.g., compliance needs), see the [Exact import via AI (Manual HTML conversion)](/products/pro/documenting/templates/create-template/#exact-import-via-ai-manual-html-conversion) method in the *Create a template* article. ::: ### Migrating PowerPoint playbooks Convert PowerPoint playbooks and training materials into Tallyfy templates. Especially useful for enterprises with dozens or hundreds of PowerPoint files acting as operational playbooks. :::tip[Why PowerPoint users love Tallyfy] **The problem**: Enterprises often have 100+ similar PowerPoint files (v1, v2, v2_final, v2_final_FINAL) with slight variations. Finding the right version is a nightmare. **The fix**: One smart template with conditional logic[^2] replaces all those versions. Twelve different files become one dynamic template that shows only relevant content based on user selections. ::: **Quick migration steps**: 1. Export your PowerPoint as PDF 2. Upload the PDF to Tallyfy's AI import 3. Choose "Procedure" for an interactive workflow template 4. Review and add dynamic features like conditional logic **What gets converted**: - Slide content becomes template steps or sections - Text boxes and tables keep 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 become step instructions **Post-import improvements**: - Add [conditional visibility](/products/pro/documenting/templates/automations/conditional-visibility-guide/) for different scenarios - Convert static text to dynamic dropdown fields - Use [snippets](/products/pro/documenting/templates/snippets/) for reusable content blocks - Set up [automation rules](/products/pro/documenting/templates/automations/) for task assignments - Add form fields to capture data that was previously written on printed slides **Enterprise migration strategy**: 1. List all operational playbooks and their variations 2. Find sections that appear across multiple files 3. Convert common content to [snippets](/products/pro/documenting/templates/snippets/) for consistency 4. Import the most complete version first as a master template 5. Add conditional logic to replace multiple files with smart branching 6. Test with users to confirm all scenarios are covered 7. Archive originals for reference but stop updating them ### AI flowchart conversion Got flowcharts in Visio, Lucidchart, or on a whiteboard? Take a picture and Tallyfy turns it into a live template. - Upload a clear image of your flowchart (PNG, JPG, or PDF) - The AI reads the shapes and text - Pick your output: - **Document**: Creates a Tallyfy document - **Procedure**: Converts each shape into a workflow step - Review and adjust as needed :::note[Manual setup needed for rules] The AI converts shapes into steps, but you'll need to manually set up rules (like conditional logic or [automations](/products/pro/documenting/templates/automations/)) after importing. ::: :::tip[Get better results] Use clear, high-resolution flowchart images. Readable text and distinct shapes help the AI convert steps correctly. ::: ### Copying templates between accounts Copy a template from one Tallyfy account to another using two IDs. #### What you need - Login access to both accounts (source and destination) - 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 - Sharing standard processes between departments or branches - Copying templates between a test account and production ### API import and export The Tallyfy API lets you manage templates programmatically. It's useful for bulk operations or custom integrations. - Export templates as JSON (good for backups) - Import templates from JSON for bulk operations - Script template creation and management See the [GitHub repository](https://github.com/tallyfy/api-support/) for code examples and details. ### Best practices for Word and PowerPoint imports - **Purpose**: Tallyfy creates online workflows, not print-ready documents. It's built for doing, not filing. - **Formatting**: Fancy Word formatting gets stripped on purpose. You'll reformat using Tallyfy's tools. It's better this way. - **Structure**: Use headings (H1, H2, H3) to organize content. Tallyfy builds a clickable table of contents from them automatically. - **Branding**: Your company branding gets applied automatically across all templates. - **Images**: Pictures from Office files might need resizing after import. - **Versions**: Tallyfy keeps one [master template](/products/pro/documenting/templates/master-templates-vs-processes/) with a full history log. No more "v2_final_FINAL" file names. - **Dynamic content**: Multiple PowerPoint versions become one template with smart branching via conditional logic. :::tip[Best practice] Get your 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 - **[Insert media](https://tallyfy.com/products/pro/documenting/templates/insert-media/)**: Tallyfy lets you insert images, videos, files, tables, links, and embedded content directly into task descriptions within templates. This makes instructions clearer and more visual for anyone following a process. ## Adding media to tasks Click the **Insert** button in the editor toolbar to add images, videos, files, tables, and links directly into [task](/products/pro/tracking-and-tasks/tasks/) descriptions in Tallyfy [templates](/products/pro/documenting/templates/). This makes instructions clearer, especially for visual or complex steps. ### Supported media types | Media Type | What it does | Upload limit | |------------|-------------|-------------| | Image | Displays inline (JPG, PNG, GIF) | 100MB | | File | Shows a download link (Docs, PDFs, etc.) | 100MB | | Video | Plays inline (uploaded or linked) | 100MB | | Link | Clickable web link | N/A | | Table | Rows and columns for structured data | N/A | | Embed URL | Live preview of external content (YouTube, Twitter, etc.) | N/A | | Page Break | Controls page breaks for printing/PDF | N/A | ### How to insert media ### Instructions by media type #### Images #### Files #### Videos :::tip[Best way to add videos] It's usually better to upload your video to YouTube or Vimeo first, then paste the link into Tallyfy. Better quality, smoother playback, and it won't use your storage. Use **URL** above or **Embed URL** below. ::: #### Tables #### Links :::tip[Create email links with variables] You can create pre-filled email links using mailto: combined with Tallyfy variables. See [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) for details. ::: #### Page breaks Add page breaks to control where new pages start when printing or saving as PDF. #### Embed URL Embed URL pulls in a live preview of external 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 more. Embedded content stays interactive. ::: ### Tips for using media - Use images to show steps that are hard to explain in words - Attach files people need while doing the task - Use videos to demonstrate how something works - Keep uploaded files under 20MB[^2] when possible - they'll load faster - Add alt text to images for accessibility - Use tables to organize structured data [^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) - **[Templates vs. processes](https://tallyfy.com/products/pro/documenting/templates/master-templates-vs-processes/)**: Tallyfy uses a single master template to spawn unlimited customized process instances, each with its own data and timeline. Template updates only affect future launches while running processes stay untouched. ## Single source of truth ![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) Templates in Tallyfy are your single source of truth - one authoritative version that generates customized processes. Update the template once, and future launches stay consistent. Running processes aren't affected. Think of it like a cookie cutter (template) and cookies (launched processes). Same shape - but each cookie gets different icing, sprinkles, or decorations. ## Template to process relationship One master template spawns multiple customized processes while each stays version-independent. [Diagram removed for brevity] **Diagram description:** A single master template generates multiple customized process instances with a continuous improvement loop. Each process has unique customizations (Client A data, Client B timeline, Client C regional rules). Feedback from running processes flows back to improve the template for future launches. **What to notice:** - **One-to-many relationship** - A single template creates unlimited process instances, each customized for different clients or regions - **Version independence** - Processes launched from v1 continue unchanged even after the template updates to v2[^2] - in-flight work stays consistent - **Continuous improvement** - Feedback from running processes improves future template versions without disrupting current ones ## Key distinctions ### Templates (blueprints)[^1] - **Purpose**: Define standard process structure and rules - **Editing**: Only users with `checklist_edit` permission can modify - **Content**: Placeholders, automation rules, and standard text - **Versions**: Revision history for compliance - **Location**: **Templates** section in Tallyfy ### Launched processes (active instances) - **Purpose**: Execute actual work with real data - **Editing**: Users fill in fields and complete tasks - **Content**: Actual client names, dates, and specific information - **Status**: Tracks progress through active workflow - **Location**: **Tracker** section in Tallyfy ## How customization works ### At the template level You control what users can and can't change when they launch a process: ### At the process level When someone launches a process from your template: ## Real-world example **Challenge**: CBRE manages hundreds of playbooks with multiple variations - agency vs. principal delivery models, different service types, and regional requirements across North America, Europe, and Asia. **Without Tallyfy**: 100+ PowerPoint files with slight variations, manual updates when standards change, version control chaos with local copies, and no way to filter content dynamically. **With Tallyfy**: One template with all variations, dynamic filtering based on user selections, instant updates when standards change, and each launched process shows only relevant content. ## Templates vs. 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 template 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 ### "Can I edit the template while a process is running?" Yes. Changes only affect future launches. Running processes continue with the version they started with. ### "If I update a template, will running processes break?" No. Running processes keep their original structure. In-flight work stays safe. :::important[Template changes don't affect running processes] **Processes are snapshots taken at launch time.** Tallyfy creates an independent copy with the template's structure at that moment. Adding tasks, changing steps, or modifying the template afterward won't change already-running processes. To apply template updates, launch a new process. ::: ### "Can different teams have different versions?" Use conditional logic instead of separate versions. One template shows different content based on team, region, or other criteria. ### "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. ## 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 rollout - Launch test processes for each major variation - Verify conditional logic works correctly - Gather feedback from pilot users ### 4. Maintain the template - Review the template regularly - Update based on process feedback - Document major version changes ## Migrating from documents to Tallyfy [^1]: Called 'blueprints' (or 'checklists') in Tallyfy API endpoints - this technical term maps to user-facing 'templates' [^2]: Uses `timeline_id` and `blueprint_timeline` fields to maintain process isolation from template changes - **[Milestones](https://tallyfy.com/products/pro/documenting/templates/milestones/)**: Milestones in Tallyfy group template steps into collapsible sections. They carry over into running processes and CSV exports. Deleting a milestone doesn't remove its steps, it just ungroups them. ## 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 Click the three-dot menu icon on a milestone header to rename or delete it. Deleting a milestone moves its steps to the unmapped section - they don't get deleted. ### 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 won't have values in these columns. - **[Using folders for templates](https://tallyfy.com/products/pro/documenting/templates/organize-templates-into-folders/)**: Tallyfy lets you create folders and subfolders to organize your workflow templates by department or function. These template folders are separate from the task/process folders used to organize running work in the Tasks and Tracker views. ## Why use template folders? Create folders in Tallyfy and move your templates into them. Once you've got 20+ templates, folders make finding the right workflow much faster. :::note[Who can organize templates?] "Light" [members](/products/pro/documenting/members/) can't organize templates into folders. Only "Standard" members (if allowed by an Admin) or "Administrator" members can create folders and move templates. ::: ## Template folders vs. process folders Tallyfy has two separate folder systems. They're independent of each other. :::note[Template folders are separate from process folders] 1. **Template folders** - used only in the **Templates** section to organize your master blueprints. 2. **Task/process folders** - used in the **Tasks** and **Tracker** views to organize *running* processes and tasks. How you organize master templates often differs from how you organize live work. **Example 1:** A template folder called "HR" might contain "Employee Onboarding." But running onboarding processes go into folders named by department - "Sales Team Onboarding" or "IT Team Onboarding." **Example 2:** All client templates live in "Client Operations." But running processes go into folders named per client - "Acme Corp Projects" or "Beta Inc Requests." ::: :::note[Folder type is locked] A template folder stays a template folder, and a process folder stays a process folder. Moving a folder doesn't change its type, so you can't accidentally turn a template folder into a process folder by dragging it. Folders sort by their assigned position, so the order you arrange them in stays consistent across reloads and across team members. ::: ### What you need - Access to the **Templates** section - Standard or Admin permissions - Light members can't create folders ### Benefits - **Find templates faster** - good folder structure cuts search time - **Group logically** - HR templates in one spot, sales workflows in another - **Cleaner view** - no more scrolling through an endless flat list - **Self-service** - new employees find what they need without asking ### Creating main folders Your new folder appears in the left panel. Click it to open or start adding templates. ![Template folders in the left panel of the Templates section](https://screenshots.tallyfy.com/tallyfy/pro/desktop-light-point-folders-templates.png) ### Creating subfolders Subfolders nest under their parent folder. ### Moving templates into folders ### Managing existing folders *Deleting a folder does **not** delete the templates inside it. They move back to the main library view (unfoldered).* ### Restoring archived templates When you unarchive a [template](/products/pro/documenting/templates/), Tallyfy remembers its original folder: - If the folder still exists, the template goes back there - If the folder was deleted, the template lands in the main library view ### Best practices Keep folder names short and obvious - "HR Templates" beats "Human Resources Documentation and Processes." Two or three levels of nesting works well. More than that creates a maze. Organize by department (HR, Sales, IT) or by function (Approvals, Onboarding, Reviews). Pick one approach and stick with it. You can also use tags alongside folders for extra categorization. Review your folder structure every few months. Delete empty folders and merge similar ones. - **[Print or export templates](https://tallyfy.com/products/pro/documenting/templates/print-download-export-templates/)**: Tallyfy lets you output templates three ways: printing to paper via the toolbar's Print option; saving as PDF by changing the print destination; or using the API to export template data as JSON files for backups and bulk automation. ## How to output templates from Tallyfy You can get templates out of Tallyfy three ways - print on paper, save as PDF, or export raw data through the API[^1]. ### Prerequisites - Read permission on the template - A printer (for physical copies) - Technical or developer help (for API export) ### Print a template Click **More** in the template toolbar, then choose **Print**. Tallyfy automatically switches to read mode before opening your browser's print dialog. :::tip[Can't see the print option?] You need read permission on the template. If you have permission but still don't see it, switch the toggle at the top from edit mode to "View" or "Read" mode. ::: ### Save as PDF The PDF option uses the same print flow - you just change the destination. ### API export for technical users The API lets you pull template data programmatically as JSON[^2] - useful for backups or moving many templates at once. :::note[Template sharing between organizations] **Direct template sharing between different Tallyfy organizations isn't currently available**. To share templates with other organizations, export via API and have them recreate the template manually. ::: #### What API export gives you - Your full template structure and settings as a JSON file - Reliable backups you can restore from - The ability to automate bulk operations - back up hundreds of templates on a schedule #### How to set it up ### Choosing the right method | Method | Best for | Format | You'll need | |------------|----------------------------------------|----------|---------------| | Print | Paper copies for meetings, offline use | Paper | Printer access| | Save as PDF| Sharing digitally, documentation | PDF file | PDF viewer | | API Export | Backups, bulk moves, automation | JSON file| Coding skills | Sharing with non-technical people? Use PDF. Doing anything programmatic? Use the API. [^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/)**: Organize your Tallyfy template library with folders, naming conventions, tags, and step grouping so teams can find and run the right process fast. Includes version control and audit cycles to keep templates accurate. ## What good organization does for your team A well-organized template library means people find the right template in seconds, not minutes. That matters because people [forget most of what they learn within a week](/products/pro/tutorials/why-documentation-training-fails-forgetting-curve/), so a tidy library becomes the place your team checks instead of guessing. Three habits do most of the work: clear names, folders that fit how you work, and tags for anything that doesn't sit neatly in a folder. The rest of this page covers those, plus how to group steps in big templates, who can see each template, and a simple routine to keep it all accurate. ## Make templates easy to find Folders, names, and tags are your three ways to keep the library searchable. Use all three together. ### Folders Tallyfy supports folders, and you can nest folders inside other folders. Pick the structure that fits your business: - **By department** - HR, Finance, Operations - **By process type** - Approvals, Onboarding, Reviews - **By frequency** - Daily, Weekly, Monthly - **By client** - for service businesses, organize by client or client type - **Hybrid** - combine methods with sub-folders (for example, Department > Process Type) ### Naming conventions Keep template names short, clear, and searchable: - Use specific names under 60 characters - Add department prefixes (HR-, FIN-, OPS-) for quick scanning - Append version numbers when needed (v2.1) - Stick to letters, numbers, and hyphens - Include keywords people actually search for Example pattern: `[Department]-[Process Name]-[Version]` ### Tags Tags give you a second way to organize beyond folders. You can search, filter, and sort by tags in Tallyfy. - Keep tags consistent across all templates - Tag attributes that don't fit into folders - like complexity, priority, or approval type - Useful tag categories: Priority (High/Medium/Low), Complexity (Simple/Moderate/Complex), Process Stage (Planning/Execution/Closing) ### Folder examples for different company sizes Use whichever of these comes closest to how your business is set up, then adjust. **Small business**: ``` ├── Core Operations │ ├── Client Onboarding │ ├── Project Management │ └── Invoicing ├── Internal Processes │ ├── HR │ └── Administration └── Archived Templates ``` **Medium business**: ``` ├── 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 ``` **Enterprise**: ``` ├── Department 1 │ ├── Process Category A │ │ ├── Active Templates │ │ └── Under Development │ ├── Process Category B │ │ ├── Active Templates │ │ └── Under Development │ └── Department Archives ├── Cross-Departmental │ ├── Approvals │ ├── Reviews │ └── Reporting └── Global Archives ``` ## Group steps in big processes Moving a long checklist into Tallyfy? If it has 50 to 100+ line items, don't make a separate step for every one. Group related actions together so the process stays readable. **Group steps when**: - The same person does several actions in a row - Actions happen in one sitting with a shared deadline - Steps are quick checkboxes - use a checklist field[^2] instead **Keep steps separate when**: - Different people handle each step - Steps happen at different times - You need separate deadlines or approvals between steps **Example** - blog post creation (75 original steps collapsed to 12): 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 setup (checklist: 7 items) 9. Publishing setup 10. Social media prep 11. Schedule publication 12. Post-publish checks (checklist: 5 items) ## Control who can see each template Tallyfy has five template-level permissions: Read, Edit, Launch, Duplicate, and Process Read. Admin users always see all templates. :::note[Complete template hiding] To completely hide a template from Standard and Light users[^1] in the Templates section, restrict **ALL THREE** permissions (EDIT, READ, and LAUNCH) for those users. If any single permission remains, the template still appears in their Templates view. ::: ## Keep templates accurate over time A template only helps if it still matches how work actually gets done. Two routines keep it that way: a change process for edits, and a regular cleanup. ### Change a template that's already in use 1. **Request** - document what you want to change and why 2. **Impact check** - will this affect running processes? 3. **Approval** - get sign-off from the template owner 4. **Update** - make the changes 5. **Notify** - tell affected team members 6. **Version** - track the change history ### Review and clean up regularly Review templates quarterly. Check for: - **Usage** - which templates get used? Archive the ones nobody touches - **Accuracy** - do steps still match how work actually gets done? - **Duplicates** - merge templates that do the same thing - **Orphans** - reassign or archive templates with no owner Archive old templates instead of deleting them. Keep a note on why each was archived and when to re-check. ### Review schedule | Template type | Review frequency | |---|---| | Critical / high-use | Quarterly | | Standard | Every 6 months | | Low-use | Annually | [^1]: View-only users who can't 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/)**: Tallyfy templates should handle one item at a time, like one employee or one invoice, rather than batches. This creates clear task ownership, precise tracking, and lets you launch hundreds of parallel instances that each progress independently. ## Design templates for one instance at a time Build your Tallyfy templates to handle one item - one employee, one invoice, one customer. Not batches. This gives you clear task ownership, precise tracking, and the ability to run many instances in parallel. Templates designed for single units scale naturally. Run them once or a thousand times. ## The bulk processing trap You've probably seen workflows like these: - "Process all invoices for the month" - "Onboard the new hires starting Monday" - "Review all contract renewals" This bulk thinking creates real problems: - **Unclear ownership** - who handles which specific invoice? - **No individual tracking** - can't see status of each item - **All-or-nothing completion** - one delayed item blocks everything - **Poor accountability** - "someone else probably did it" Instead, design templates for single instances: - "Process invoice #12345" - "Onboard John Smith" - "Review Acme Corp contract renewal" You get clear ownership, precise tracking, parallel processing, and one owner per task. ## Example: Conference speaker management **Wrong - bulk design**: "Manage all conference speakers" - Task: "Collect bio from speakers" - who contacts which speaker? - Task: "Arrange travel" - mixing 10 speakers' flights in one task - If one speaker delays, everything stalls **Right - unit design**: "Onboard conference speaker" 1. Launch a separate process for each speaker 2. Each process tracks one speaker's journey: - Collect bio from Jane Doe - Arrange Jane's travel (conditional logic for local vs. remote) - Process Jane's payment - Send Jane's session details Result - perfect visibility, clear ownership, parallel progress. ## How to convert bulk thinking to units ### Identify the true unit Ask: "What's the single thing we're processing?" - Not "employees" - one employee - Not "orders" - one order - Not "maintenance tasks" - one equipment item ### Name templates clearly - Poor: "Monthly invoice processing" - Good: "Process single invoice" - Best: "Process invoice - Standard workflow" ### Design for one, launch for many Your template handles one invoice. Need to process 100? Launch 100 separate processes. You can call the Tallyfy API repeatedly or use automation tools to launch multiple instances from a list. ### Use clear process names When launching, use specific identifiers: - "Invoice #2024-1234 - Acme Corp" - "Onboard: Sarah Johnson - Marketing Manager" - "Equipment Inspection: Crane #5 - Q1 2025" ## Common scenarios ### Employee onboarding **Wrong**: "Onboard Q1 new hires" **Right**: "Onboard new employee" (launch per hire) Each employee has different start dates, department requirements, equipment needs, and training schedules. ### Customer implementation **Wrong**: "Implement all January customers" **Right**: "Implement customer account" (launch per customer) Each customer has unique requirements, timelines, contacts, and success criteria. ### Document processing **Wrong**: "Review all contracts" **Right**: "Review contract" (launch per contract) Each contract needs a specific reviewer, individual negotiation tracking, separate approval chains, and its own deadline. ## Advanced patterns ### Conditional logic per unit When you design for units, conditional logic works cleanly: ``` IF Speaker Location = "International" THEN - Add visa assistance task - Include customs forms - Extend timeline by 2 weeks ``` Each process adapts to its specific needs. No manual checking required. ### Parallel processing With 20 employee onboarding processes running at once: - HR handles background checks across all hires - IT provisions equipment based on start dates - Managers review their specific new hires Everyone moves at their own pace. No waiting for the slowest item. ### Metrics and insights Unit-based design gives you real data - average onboarding time, which steps take longest, and whether you're hitting deadlines. Tallyfy exports analytics data for analysis in your BI tools.[^1] Bulk processes only tell you "completed or not." That's not useful. ## When bulk operations make sense Some tasks within a unit process can be bulk: - "Send welcome email to all attendees" - "Generate monthly report of all processed invoices" - "Archive completed contracts" These work because they're reporting or communication tasks. Nobody's waiting on them to continue their work. ## Converting existing bulk processes Ask yourself: 1. Can tasks be assigned to specific people for specific items? 2. Do you need to track individual item status? 3. Could one item's delay block others unnecessarily? 4. Would parallel processing help? If you answered "yes" to any of these, convert to unit-based design: 1. **Document current bulk process** 2. **Identify the natural unit** (invoice, employee, order) 3. **Redesign for single unit** with clear ownership 4. **Test with one instance** 5. **Launch multiple instances** via API or automation 6. **Track improvements** in clarity and speed ## Tips for unit-based templates ### Use form field variables - `{{Employee Name}}` - `{{Invoice Number}}` - `{{Customer Company}}` These variables (from kick-off form fields) make each instance clearly identifiable in process names. ### Design for the 80% case Build for the standard scenario, then use conditions for exceptions. Don't overcomplicate. ### Keep related units linked Use task comments to reference related processes: - "See also: Contract Review #123" - "Parent project: Q1 Implementation" ### Run reports across instances While each process is unit-based, you can still run reports across all instances and update the template for all future launches. [^1]: Tallyfy exports process analytics data (completion times, task durations) for analysis in external BI tools when analytics is enabled for your organization. - **[Edit a template](https://tallyfy.com/products/pro/documenting/templates/edit-templates/)**: Click the Edit icon on any template card in Tallyfy to open the Edit view. From there, you can modify steps, descriptions, settings, and permissions. ## Editing templates Click the **Edit** icon (pencil) on any template card to open the Edit view. From there, you can modify steps, descriptions, settings - everything about your [template](/products/pro/documenting/templates/). :::note[Who can edit templates?] [Members](/products/pro/documenting/members/) with the "Light" role **can't** edit templates. The template creator, "Administrator" members, and "Standard" members with explicit edit permission for that template can make changes. ::: 1. Go to the **Templates** library. 2. Find the template you want to change. 3. Click the **Edit** icon (pencil) on the template card. ![Edit icon on a Tallyfy template card](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-open-edit-mode-template.png) This opens the **Edit view** where you can change steps, descriptions, and settings. ![Template edit view in Tallyfy](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-show-template-created-by-tallyfyai.png) The articles below cover each type of edit in detail. - **[Automations](https://tallyfy.com/products/pro/documenting/templates/automations/)**: Tallyfy automations are simple IF-THEN rules added to templates that automatically adapt running processes based on form field entries and task events. They control step visibility, assignments, deadlines, and webhooks so workflows route themselves without manual intervention. ## Why Tallyfy is the AI control layer | What Tallyfy does | Why it matters in the age of AI | |---|---| | Define process steps | You can't automate anything without a recipe. | | Hand small tasks to AI | Massive reduction in mistakes, omissions, and hallucination. | | People approve work | Accountability. You can't blame AI for mistakes. | | Hybrid people + AI tasks | AI can't do every task in a process. | | Track real-time status | Tracking AI sessions at scale is a nightmare. | | Gradually shift tasks to AI | A total re-do will break a process that works today. | ## What are automations? Tallyfy automations are IF-THEN rules you add to a [template](/products/pro/documenting/templates/). They make each [process](/products/pro/tracking-and-tasks/processes/) adapt based on what users enter in [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) and what happens to [tasks](/products/pro/tracking-and-tasks/tasks/). No manual routing needed. For AI-powered task completion, see [BYO AI integration](/products/pro/integrations/byo-ai/). Automations are also what keep a process reliable when AI is involved, since each task gets checked and routed before the next one runs. See why that matters in the [AI task reliability calculator](https://tallyfy.com/tools/ai-task-reliability/). :::tip[Think of automations like a thermostat] Your thermostat follows a simple rule: **IF** temperature drops below a set point, **THEN** turn on the heat. Tallyfy automations work the same way: - **IF** something happens in your process (a form answer is "Urgent", a task gets approved, or a step expires) - **THEN** Tallyfy fires an action (assign a task to a manager, show a hidden step, or trigger a webhook) ::: :::tip[Automations are like "choose your own adventure"] A customer selects "Complaint" as a support ticket type - the automation routes it to a specialized team. They pick "Feature Request" instead - it goes to the product backlog. One [template](/products/pro/documenting/templates/) handles multiple scenarios, guiding each [process](/products/pro/tracking-and-tasks/processes/) down the right path. ::: ### Rule components Every automation rule has two parts: conditions and actions. #### Conditions (the "IF" part) Conditions tell the automation *when* to fire. Two categories: **Step conditions** - based on what happens to a task: - Task completed, reopened, approved, rejected, acknowledged, or expired - Task not assigned **Form field conditions** - based on data entered in step form fields or kick-off form fields: - Contains / doesn't contain a value - Equals / doesn't equal a value - Equals any of several values - Greater than / less than (for numbers) - Is empty / isn't empty You can combine multiple conditions with AND/OR logic. #### Actions (the "THEN" part) When conditions are met, Tallyfy fires one or more actions on a target step: - **Visibility** - show or hide a step - **Assignment** - assign, unassign, replace assignees, or clear all assignees on a task - **Deadline** - set a deadline before or after the trigger point, in minutes, hours, days, weeks, or months - **Status** - reopen a completed task (useful for approval loops) - **Webhook** - send an HTTP request to an external URL when conditions are met :::note Visibility and deadline actions can only target each step once within a single automation rule. ::: ### Naming your rules Good names save time when debugging. Be specific: - "Show steps for USA customers only" beats "Customer rule" - "Assign to manager if urgent" beats "Rule 1" ### Getting started Browse [automation examples](/products/pro/documenting/templates/automations/examples/) for common patterns like service-level routing, approval loops, and dynamic assignment. - **[Snippets](https://tallyfy.com/products/pro/documenting/templates/snippets/)**: Snippets in Tallyfy are reusable rich-text blocks that admins create once and any member can insert into templates or tasks. Updating a snippet in one place automatically pushes the change everywhere it's used. ## What are snippets? Snippets are reusable text blocks in Tallyfy. Save them once, insert them anywhere - templates, tasks, comments. When you update a snippet, every place that uses it gets the new version automatically. Tired of typing the same compliance disclaimer repeatedly? Create a snippet. Done. :::tip[Snippets = rubber stamps] Think of a snippet as a **rubber stamp** with your company address or legal notice. Instead of typing it each time, you "stamp" it where needed. If the address changes, update the stamp once - the change shows up everywhere you've used it. ::: ### What snippets can contain Snippets hold rich text content - anything you'd normally type in the editor: - Standard instructions for common procedures - Company policies referenced across multiple templates - Legal disclaimers - Technical terms that need exact wording - Contact information that changes periodically :::important[What snippets can't do] **Snippets are text-only.** They can't contain: - **Form fields** (checkboxes, dropdowns, date pickers) - **Task structures** (assignees, deadlines, dependencies) - **Interactive elements** or **conditional logic** If you need reusable tasks with form fields, create a master template and copy tasks from it to other templates manually. ::: ### Why use snippets? - **Consistency** - your legal disclaimer stays identical across every document - **One-time updates** - change one snippet, and it updates across all templates and steps that reference it - **Admin control** - only Admin members can create, edit, and delete snippets, so your approved text stays approved ### How the snippet workflow works 1. **Create** - an Admin goes to **Settings > Organization > Snippets** and creates a new snippet with a title and rich text content 2. **Insert** - any member opens the editor in a template or task description and inserts the snippet from the reference panel 3. **Update** - an Admin edits the snippet later, and every place that references it shows the updated content automatically 4. **Delete** - when an Admin deletes a snippet, Tallyfy also removes its references from all templates and steps ### Where snippets work best - Legal notes in contracts and process templates - Standard operating procedures shared across workflows - Company policy reminders - Technical definitions requiring exact wording - Contact info that changes when people move roles - Form-filling instructions for recurring tasks - **[Variables](https://tallyfy.com/products/pro/documenting/templates/variables/)**: Variables in Tallyfy are placeholders that automatically carry data entered in one process step (like a customer name or order number) to every other step that needs it. They eliminate copy-paste errors and enable personalized task titles and dynamic automation triggers based on form field values. ## What are variables? [Variables](/products/pro/documenting/templates/variables/) in Tallyfy are placeholders that grab information from one step in your [process](/products/pro/tracking-and-tasks/processes/) and show it wherever else you need it. No more copy-pasting data between steps. :::tip[Variables = Mail Carriers] Someone types a **Customer Name** at the start of a process. A variable picks up that name and delivers it to every step that needs it - task titles, descriptions, emails. The name just appears. This cuts out copy-paste errors and saves real time. ::: ### Why use variables? - **Pass data** - information entered in step 1 automatically appears in steps 5, 8, and 12 - **Live updates** - text updates instantly based on what people type in - **Personalize** - your [task](/products/pro/tracking-and-tasks/tasks/) instructions show the actual client's name, not just "the client" - **Trigger automation** - set up [automation](/products/pro/documenting/templates/automations/) rules that react to variable values (if Customer Type = "VIP", route to senior staff) - **Stay consistent** - that order number stays identical everywhere it appears ### How variables work 1. **Source**: Variables pull data from [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) on your template steps or kick-off form. 2. **Insert**: In the template editor, click the **insert variable** dropdown in the step description toolbar to pick a field. Tallyfy inserts a `{{alias}}`[^1] placeholder. 3. **Collect**: Someone fills in the form field during a running process. 4. **Display**: When the process reaches the later step, Tallyfy swaps the placeholder with the actual value entered. ### Variable sources Any [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) you add to template steps or the kick-off form becomes a variable source: - Text and textarea fields - Date fields - Dropdown menus, radio buttons, or multi-select checklists - Email fields - File upload fields - Table fields - Assignee picker fields Tallyfy also provides built-in system variables like the current task ID and process ID. ### Common uses - Client name appears in every relevant task title automatically - A due date from step 2 shows up in steps 10, 15, and 20 - Approval tasks reference exact answers from earlier steps - [Document templates](/products/pro/documenting/documents/) fill themselves with process-specific details - Dropdown selections trigger different workflow paths (pick "Rush Order" and Tallyfy routes it accordingly) [^1]: Mustache syntax - double curly braces wrap the form field's auto-generated alias (e.g. `{{text-a1b2}}`) that's a unique identifier for each field ### Edit templates - **[Add default watchers to a template](https://tallyfy.com/products/pro/documenting/templates/edit-templates/add-default-watchers/)**: Default watchers in Tallyfy are members or groups assigned at the template level who automatically receive email progress updates on every process launched from that template without being given any tasks or assignments themselves. ## How default watchers work Default watchers are [members](/products/pro/documenting/members/) or [groups](/products/pro/documenting/groups/) you pick on a template who automatically watch every [process](/products/pro/tracking-and-tasks/processes/) launched from it. They get progress updates by email but aren't assignees and have no tasks to complete. It's the easiest way to keep a manager, a coordinator, or a whole team in the loop without giving them work. You set this up once on the template. After that, every [launch](/products/pro/launching/) adds those people as watchers the moment the process starts - nobody has to remember to star anything. ### Set default watchers on a template You need permission to edit the template to change this setting. 1. Open the template in **Edit** mode. 2. Click **Settings** in the top navigation, then choose **Summary**. 3. Scroll to the bottom of the Summary tab to find the **Default watchers** row. 4. Pick the members and groups who should watch every process launched from this template. From then on, each new process launched from the template includes them as watchers automatically. Processes that are already running aren't changed - you can add watchers to those directly from the process itself. ### What watchers get Watching is inform-only. A watcher isn't an assignee and gets no tasks to complete - they simply stay informed about progress. Tallyfy sends them email updates at the notification frequency they've chosen for watched items. By default, updates arrive as a periodic digest instead of a separate email for every event. Each watcher controls their own frequency and settings from the [Favorites](/products/pro/tracking-and-tasks/tracker-view/organize-processes/how-can-i-favorite-and-filter-processes-on-tallyfy/) section. ### How groups are handled When you add a group as a default watcher, Tallyfy expands it at launch - every member of the group becomes a watcher of the new process. If someone is picked directly and also belongs to a group you added, the direct entry wins and its notification settings apply. ### When someone unwatches Watchers stay in control of what they follow. If a watcher removes themselves from a launched process, Tallyfy never adds them back to that process - not on a relaunch, not on a re-sync. Their choice is respected. ## Add watchers to a running process or task Default watchers cover new launches, but you can also add watchers after a process is underway. Open the watcher control in the header of any live process or task to add other people as watchers - not just yourself. That's useful when someone needs to follow one specific process rather than everything launched from a template. - **[Rename a template](https://tallyfy.com/products/pro/documenting/templates/edit-templates/change-name/)**: Rename a Tallyfy template through the Settings panel or the pencil icon in Edit view. Changes only apply to new processes. ## Renaming a Tallyfy template Rename any [template](/products/pro/documenting/templates/) in Tallyfy using either the Settings panel or the pencil icon in the Edit view. Both methods open a rename dialog where you'll type the new name and save. :::note[Changes only affect future processes] Renaming a template doesn't affect processes already running. The new name only applies to processes started *after* the rename. ::: **Method 1: Via the Settings panel** 1. Open the template in Edit mode. 2. Click **Settings** in the top toolbar. 3. Click the template name at the top of the settings panel. 4. Type the new name in the rename dialog and click **Save**. ![Renaming a template through the Settings panel](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-change-template-name.png) **Method 2: Via the Edit view header** 1. Open the template in Edit mode. 2. Click the **pencil icon** next to the template name at the top of the editor. 3. Type the new name in the rename dialog and click **Save**. Template names can't exceed 250 characters. ![Renaming a template from the Edit view header](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-rename-template-from-edit-view.png) - **[Assign steps in the Tallyfy template builder](https://tallyfy.com/products/pro/documenting/templates/edit-templates/assign-steps-in-the-tallyfy-template-builder/)**: Tallyfy lets you assign template steps to specific members, groups, job titles, or guests through the Assign tab. You can also leave steps unassigned or use automation rules to route tasks based on form answers or conditions. ## How to assign steps in Tallyfy templates Click the **Assign** tab for any step to pick who handles it - specific members, groups, job titles[^2], or guests. You can also leave steps unassigned or let automation rules route assignments dynamically. Assignments determine who gets each task when someone launches your process. You can lock in specific people or keep things flexible with role-based assignments. ### Prerequisites - Admin 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 ### Specific members Assigns the same person every time. 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**: Type and select the member's name from the dropdown. ### Groups Groups let multiple people share responsibility. Any group member can complete the task. **When to use**: - Support tickets any team member can handle - Document reviews where any QA person can take a look - Approvals where any manager can sign off **How**: Type the group name and select it. You'll need to [create groups in Settings](/products/pro/documenting/groups/how-to-manage-groups-and-assign-tasks-in-tallyfy/) first. ### Job titles Job titles[^2] let you define what role you need, then pick the specific person later. Great for flexible workflows. **When to use**: - Different people handle the same role depending on the project - You rotate responsibilities based on availability - The same template works across departments with similar roles **How**: 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 **Example**: Your client onboarding needs an "Account Manager" - but which one depends on the client. With job titles, whoever launches the process picks the right person. ### Guests [Guests](/products/pro/documenting/guests/) are people outside your company. They get an email with a secure link - no Tallyfy account needed. **When to use**: - Getting client approvals or feedback - Collecting documents from vendors - Having contractors complete specific tasks **How**: - Know the email? Enter it directly in the assignment dropdown - Not sure who yet? Leave it blank and let the process launcher decide ### Unassigned steps Leaving steps unassigned gives you flexibility: - **"Assign launcher automatically" ON** - the person who launches the process gets the task - **"Assign launcher automatically" OFF** - the task stays unassigned until someone claims it **When to use**: - Ad-hoc tasks where assignment depends on workload - Tasks where anyone can volunteer - Processes where the launcher should handle initial steps :::caution[Important: group assignments with automatic launcher assignment] When a step is assigned to a group AND "Assign launcher automatically" is enabled, Tallyfy adds the process launcher 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, either: - Turn OFF "Assign launcher automatically" for that step - Use specific member assignments instead of groups - Use automation rules to control assignments dynamically ::: ## Advanced techniques ### Dynamic assignment with automation [Automation rules](/products/pro/documenting/templates/automations/) can change assignments based on what's happening in your process: - Add assignees based on form answers (someone picks "High Priority"? Auto-assign your senior team) - Replace assignees when conditions change - Clear assignments to create unassigned tasks - Route tasks based on amounts, regions, or priorities **Example**: Purchase request over $10,000? Goes to the CFO. Under that? Department manager handles it. No manual routing needed. ### Requiring all assignees to complete Need everyone to sign off? Here's how: 1. Assign multiple people or groups to the same step 2. Turn on "All assignees must complete this task" (the `everyone_must_complete` setting) 3. The task waits until every assignee marks it done Good for board approvals, multi-department sign-offs, and reviews needing multiple perspectives. ### Tips - **Be specific with job titles** - "Senior Marketing Manager" beats "Manager." You'll avoid confusion at launch time. - **Groups spread workload** - specific assignments are great for accountability, but watch for overloading one person. - **Plan for absences** - groups and job titles give you built-in backup when someone's out. - **Test first** - launch a few test processes to see how assignments flow in practice. ## Troubleshooting ### "I can't see a group in the assignment dropdown" The group needs to exist first. Go to **Settings** > **Organization** > **Groups** to create it. Only admins can create groups, and the "Allow group management" org setting must be enabled. ### "The wrong person got assigned" Check these: - Is "Assign launcher automatically" turned on? It may be overriding your setup. - Are any automation rules switching assignments? - Using job titles? Someone needs to pick the actual person during launch. ### "Guests aren't receiving task notifications" - Double-check the email address for typos - Ask them to check spam folders - Verify that "Prevent guests from making or seeing comments" (`prevent_guest_comment`) isn't blocking what they need ### "Multiple people need different parts of one task" Split the task into separate steps, each with its own assignments. [^1]: A view-only role that can't complete tasks or edit templates [^2]: A role-based routing feature that keeps templates flexible without hardcoding specific assignees - **[Add a description to a template](https://tallyfy.com/products/pro/documenting/templates/edit-templates/add-description/)**: Add descriptions to templates and steps in Tallyfy. Open Edit mode and click Settings for the template summary, or click directly on any step for step-level details. ## How to add descriptions Open your [template](/products/pro/documenting/templates/) in **Edit** mode, then click **Settings** (gear icon in the sub-nav bar) for the overall template description - or click directly on any step for step-specific descriptions. :::note[Changes only affect future processes] Changes you make to a template (like adding descriptions) only apply to *new* [processes](/products/pro/tracking-and-tasks/processes/) started *after* you save. Already-running processes aren't affected. ::: 1. Open the [template](/products/pro/documenting/templates/) in **Edit** mode. 2. Where you add the description depends on what you're describing: * **Overall template description**: Click the **Settings** button (gear icon) in the sub-nav bar, then open the **Summary** tab. You'll see a rich text Description box. ![Clicking the Settings gear icon on a template in Edit mode](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-click-config-template.png) ![Template description field in the Settings Summary tab](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-description-template.png) * **Step description (Procedure templates)**: Click directly on the [step](/products/pro/tracking-and-tasks/tasks/) you want to describe. A panel opens on the right with the description editor. * **Document templates**: The main content area is your editing canvas for the primary text. 3. Type your description into the text box. 4. For step descriptions, Tallyfy auto-saves as you type. For the template-level description in Settings, click **Save** when you're done. :::caution[Pasting content might lose formatting] If you paste text from programs like Word or Google Docs, the original formatting (fonts, colors, complex layouts) might not carry over exactly. Tallyfy uses its own standard formatting for consistency. ::: - **[Change a template's status](https://tallyfy.com/products/pro/documenting/templates/edit-templates/change-template-state/)**: Tallyfy uses four template statuses (Started, In progress, Finishing, Published) to show readiness. Any member can update status from the Templates list, while editing in the Template Editor requires appropriate role permissions. ## What template status means A [template's](/products/pro/documenting/templates/) status tells your team whether it's still being built or ready to use. Tallyfy has 4 status options: - **Started** - Just beginning to create the template (that's the default for new templates). - **In progress** - Currently being worked on. - **Finishing** - Almost done, possibly under final review. - **Published** - Complete and ready to launch processes from. :::note[Who can change the status?] Status permissions work differently from editing permissions: - **Administrators** - Can change status from the Templates list or from within the Template Editor settings. - **Standard members** - Can always change status from the Templates list. They can also change it in the Template Editor settings if they have edit permission for that template. - **Light members** - Can't edit templates, but they can still change status from the Templates list. ::: ## How to change template status **Method 1: From the Templates list** **Method 2: From the Template Editor (Admins and Standard members with edit rights)** - **[Edit steps](https://tallyfy.com/products/pro/documenting/templates/edit-templates/edit-steps/)**: Edit template steps in Tallyfy by adding new ones or modifying details like descriptions, assignments, step types, form fields, and deadlines. Configure advanced settings including webhooks, mandatory flags, and auto-assignment rules. ## Editing steps in templates Add new steps or edit existing ones directly in Tallyfy [templates](/products/pro/documenting/templates/). :::note[Who can edit steps?] [Members](/products/pro/documenting/members/) with a "Light" role can't edit templates or steps. Only "Standard" members (if allowed by an Admin) or "Administrator" members can. ::: ### Adding new steps Open your template in Edit mode, scroll to the bottom, click **Add Step**, type a name, and press Enter. That's it. ### Modifying existing steps To modify a step: - Go to the **Templates** library - Find your template and click the **Edit** icon (pencil symbol) ![Template edit mode with pencil icon highlighted](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-open-edit-mode-template.png) In edit mode, click any step to open its details panel on the right. Here's what you can change: #### Step description Write 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 screen recording often explains a step better than paragraphs of text. Embed videos for complex tasks. ::: #### Assignment * **"Nobody right now"**: What happens at runtime depends on the **Assign launcher automatically** setting (in the Advanced tab). It's ON by default - the person starting the process gets assigned. If OFF, the task stays unassigned. * **Assigning Groups**: [Create the group first](/products/pro/documenting/groups/how-to-manage-groups-and-assign-tasks-in-tallyfy/) in Tallyfy before assigning a task to it. ![Assigning a task to a member in the step details panel](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-assign-a-task-to-somebody.png) #### Step type Different step types have different behaviors and buttons (e.g., Approve/Reject steps). 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] Use the "Expiring" type for FYI items or optional info. 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. Great for weekly updates 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 look like standard messages. 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 details. :::caution[Checklist field saving issue] If you see a "Capture ID field is required" error when saving a step with checklist fields, it usually means: - You added checklist options but didn't save the field configuration first - The checklist field validation rules are incomplete **To fix**: 1. Click the checklist field to open its settings 2. Confirm all checklist items are properly added 3. Set the validation rules (e.g., "at least one" or "all items") 4. Click outside the field settings to save 5. The template should now save without errors If the error persists, refresh the page and re-enter the checklist field configuration. ::: #### Deadlines and timings :::note[Start time vs deadline] - **Start time**: When work should **begin**. Helps with planning but isn't enforced. - **Deadline**: When work must be **complete**. This is the due date that determines overdue status. Both can be set for process tasks (via the template editor) and one-off tasks. Example: start time of "Monday 9 AM" and deadline of "Wednesday 5 PM". ::: :::note[Overall process deadlines] Your process's overall deadline depends on which task has the latest due date from launch. 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 step finishes. ::: :::tip[Bulk deadline management] The template editor doesn't support bulk editing of deadlines across multiple steps. Each step's deadline must be set individually. **Alternatives**: 1. **Power Builder** - Bulk step creation and deadline tool (contact support for access) 2. **Professional Services** - Tallyfy's team can help with large-scale template setup 3. **Template duplication** - Create a master template with standard deadlines, then duplicate and adjust Contact support@tallyfy.com for Power Builder access or professional services help. ::: #### Advanced settings - **Launch another process when complete**: "Yes" auto-starts another process (from a different template) when this task finishes. You can inject tasks into the current process or start a separate one. See [Launch another process guide](/products/pro/launching/launch-process-when-task-is-completed/). - **All assignees must complete this task**: "Yes" means the task isn't done until *every* assignee marks it complete. Doesn't apply to Administrators. - **Assign launcher automatically**: ON by default. If a step has *no* assignees, the person who launches the process gets assigned. Turn OFF to leave it unassigned. - **Task is mandatory**: "Yes" means this step can't be removed when someone launches the process. - **Only assigned members can complete or edit**: "Yes" restricts the task to assigned people only (Administrators always have access). - **Emit outbound webhook when completed**: "Yes" sends a notification to another web service via a [webhook](/products/pro/integrations/webhooks/) when this task finishes. - **Prevent guests from making or seeing comments**: "Yes" hides comments from any [guests](/products/pro/documenting/guests/) assigned to this task. - **Unique Step Alias**: An internal ID for this step, used for [webhook](/products/pro/integrations/webhooks/) and [API](/products/pro/integrations/open-api/) integrations. - **Tags**: Add tags to this step for filtering and organization. :::note[Webhooks and integrations] For more on [Webhooks](/products/pro/integrations/webhooks/) and connecting Tallyfy to other tools, see the [Integrations](/products/pro/integrations/) section. ::: - **[Add guidance text to a step](https://tallyfy.com/products/pro/documenting/templates/edit-templates/how-to-add-guidance-text-to-template-steps/)**: Add rich-text guidance instructions below any form field label in a template step. People filling out forms see helpful context like format examples or resource links right where they need them. ## Adding guidance text to form fields Guidance text appears directly below a [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) label in Tallyfy, giving people instructions right where they need them. It's great for specifying formats, examples, or links to extra resources. ![Guidance text settings in a Tallyfy template step form field](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-add-guidance-text.png) When someone runs the process, you'll see your guidance text in italics below the field label. Any URLs you include become clickable automatically. - **[Assignment types](https://tallyfy.com/products/pro/documenting/templates/edit-templates/understanding-assignment-types/)**: Assign process steps using Fixed mode for specific people, Dynamic mode for role-based job titles chosen at launch, or Guest mode for external collaborators. Automation rules can add, replace, or clear assignees based on form responses. ## How step assignments work Every step in a Tallyfy [template](/products/pro/documenting/templates/) needs an assignment type. This controls who gets each [task](/products/pro/tracking-and-tasks/tasks/) when someone [launches your process](/products/pro/launching/). The assignment panel offers three modes: **Fixed**, **Dynamic**, and **Guest**. ### Fixed assignment (specific people or groups) Pick this when you know exactly who should handle a step. Every time. #### Specific people - The same person gets this task each time the process runs - No need to choose assignees at launch - it's already decided - Great for tasks with clear ownership, like approval from your CFO *How to:* Click the step > select **Fixed** > type a member's name #### Groups Groups work like pre-built teams. Use them when: - Multiple people could handle the task - You don't want to list everyone individually - Your team changes but the group stays constant *How to:* Click the step > select **Fixed** > 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. ::: ### Dynamic assignment (job titles) Sometimes you know the *role* that should handle a task - but not which specific person. That's what job titles are for. :::tip[Job titles = casting roles in a play] - **Fixed:** Like choosing specific actors beforehand. Same actors every show. - **Dynamic (Job Title):** Like saying you need a "Lead Actor" but not picking who yet. When the play starts (process launches), you pick who fills the role *for that run*. Different people can fill it each time. This works well when the person depends on the project or client, but the job function stays the same (e.g., always needs a "Project Manager"). ::: How it works: - You define a role in your template ("Legal Reviewer", "Project Manager", etc.) - When someone [launches the process](/products/pro/launching/), they pick who fills that role - Next run? They can choose someone different. *How to:* Click the step > select **Dynamic** > choose or create a job title ### Guest assignment Need someone outside your company to complete a [task](/products/pro/tracking-and-tasks/tasks/)? Use guest assignments for clients, vendors, or contractors who don't have Tallyfy accounts. *How to:* Click the step > select **Guest** > add their email (or leave blank to decide at launch) What happens at launch: - If you set an email in the template, Tallyfy assigns the [guest](/products/pro/documenting/guests/) automatically - If you left it blank, you'll enter the email when launching - Either way, they get an email with a direct link - no login needed ### Automation rules for assignments [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. For example, if someone selects "Budget over $10K" in a form field, you can route approval to senior management automatically. Your rules can: - **Add** extra assignees alongside existing ones - **Replace** the current assignee with someone else - **Clear** all assignees and start fresh See [Automate task assignments](/products/pro/documenting/templates/automations/actions/asignment-actions/) for the full guide. ### Automations - **[Conditional visibility](https://tallyfy.com/products/pro/documenting/templates/automations/conditional-visibility-guide/)**: Tallyfy lets you show or hide entire workflow tasks based on form field values using IF-THEN rules with AND/OR logic. One template can handle multiple process variations instead of maintaining separate templates for each path. ## What conditional visibility does Show or hide entire tasks based on form field values. Someone fills out a field, Tallyfy checks your IF-THEN rules[^2], and tasks appear or stay hidden. You can combine conditions with AND/OR logic. This works at the **task level only** - you can't show or hide individual form fields within a task. ### Key limitations - **Tasks only** - you can't conditionally show/hide individual form fields, just whole tasks - **One-way visibility** - once a task appears, it stays visible unless someone manually hides it - **Hidden tasks stay incomplete** - hidden tasks get an "auto-skipped" status and can't trigger completion-based automations - **Cross-step references allowed** - you can reference kick-off form fields, step completion status, or form fields from any step in your conditions :::note[Form field conditional logic not supported] 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 You'll need a Pro plan (or active trial), plus a [template](/products/pro/documenting/templates/) with form fields and [automation rules](/products/pro/documenting/templates/automations/). ## Practical examples ### Simple Yes/No branching ``` Kick-off form field: "Shipping Type" (Dropdown: Domestic, International) Conditional task: "Customs Documentation" Rule: IF "Shipping Type" equals "International" THEN show this task ``` ### Multiple AND conditions ``` 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 ``` Don't create two separate rules here. Use one rule with both conditions joined by AND. ### OR conditions ``` 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 ``` ### Decision-tree quotation workflow ``` 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 Step 3 - Services Questions (conditional): Rule: IF "Industry Type" equals "Services" THEN show this task Step 4 - Small Business Package (conditional): Rule: IF "Company Size" equals "Small" AND "Industry Type" equals "Manufacturing" 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 ``` The process reveals only relevant questions based on previous answers. :::tip[Using kick-off fields for process branching] Use kick-off form fields to control your entire process flow instead of maintaining multiple templates: 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 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 ### Tasks from previous selections still visible User selects "Corporation", sees corporate tasks, then changes to "LLC" - but corporate tasks remain. Tallyfy doesn't auto-hide previously shown tasks. Three workarounds: 1. Add "step is complete" as an extra condition so tasks only appear after the selection step is finished 2. Train users to [manually hide tasks](/products/pro/tracking-and-tasks/tasks/manually-show-hide-tasks/) that aren't relevant 3. Use separate templates for very different paths ### Conditions not triggering - **Timing** - the form field must be completed before the conditional task's position in the workflow - **Field references** - double-check you're referencing the correct field (case matters) - **Logic errors** - AND requires all conditions to be true, OR requires just one - **Data types** - number comparisons (greater than, less than) need numeric field validation on text fields ### Hidden steps blocking completion-based automations Hidden tasks have "auto-skipped" status. They can't be completed, so any rule checking "IF Step X is complete" won't trigger if Step X is hidden. Design your workflow so completion checks only target visible steps, or use the original condition that would've shown the step instead. ### Too many conditional paths If you've got 20+ conditional branches, consider grouping related tasks under shared conditions, launching sub-processes for complex branches, or splitting into multiple simpler templates. ## Best practices - **Plan first** - map out all paths before building. Identify which tasks are always needed vs. conditional, and group related ones together. - **Name clearly** - use names like "Corporate Filing Tasks (if Corporation selected)" so it's obvious when tasks appear. - **Test every path** - launch test processes for each condition combination. Verify tasks appear in the right order. - **Add context for users** - include notes in conditional tasks explaining why they appeared. Train users on [manually hiding tasks](/products/pro/tracking-and-tasks/tasks/manually-show-hide-tasks/) if needed. - **Keep it simple** - avoid conditions on conditional tasks. Use binary choices when possible. ## Advanced patterns ### Sequential conditional tasks Reveal tasks one at a time instead of all at once: ``` 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] ``` ### Conditional task groups Apply the same condition to related tasks: ``` If "Department" = "HR" then show: - Task 1: Collect employee information - Task 2: Background check - Task 3: Equipment requisition - Task 4: IT account setup ``` ### Enterprise playbook filtering For managing 12+ variations (e.g. by delivery model, service type, and region) without separate templates: Use [snippets](/products/pro/documenting/templates/snippets/) for content that repeats across variations. ### Default paths Always include a fallback for when no conditions match: ``` 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 Consider alternatives when: - You have more than 5-6 major conditional branches - Users frequently change their initial selections - Different teams handle entirely different branches Better options: multiple specialized templates, API-launched sub-processes, or webhook integrations to external routing logic. ## Future - slides with conditional logic :::note[Coming soon] A slides feature will let you create slide-based playbooks where entire slides appear based on user selections - instead of showing/hiding individual tasks. **How it'll work**: - Create slides with your content - Set IF-THEN rules at the slide level - Users answer questions at the start - Only relevant slides appear in their playbook **Good for**: enterprise playbooks with many variations, role-based training materials, region-specific compliance procedures. ::: [^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 automations use IF-THEN rules instead of flowcharts. They watch user inputs and adjust workflows by showing or hiding steps, reassigning tasks, and changing deadlines using AND/OR conditions evaluated left to right. ## How automation logic works Tallyfy [automations](/products/pro/documenting/templates/automations/) watch what users enter and adjust your workflow automatically. Simple IF-THEN rules adapt your processes to different scenarios. :::tip[Why simple logic instead of flowcharts] Flowcharts get complicated fast, especially for big processes. IF-THEN rules are easy for *anyone* to understand, even without technical training. You build processes that collect user input and change their flow based on responses. ::: ### Basic "IF... THEN..." structure Every [automation](/products/pro/documenting/templates/automations/) follows this pattern: ``` IF [something is true] THEN [do this action] ``` #### The condition (IF part) Conditions check what users enter and watch for specific responses. **Examples:** - IF a user selects "Urgent" in a [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) - IF a [task](/products/pro/tracking-and-tasks/tasks/) is approved by a manager - IF a task is completed on time, late, or early - IF a form field contains (or doesn't contain) a specific value #### The action (THEN part) Actions change your process based on what conditions find. **Examples:** - THEN show or hide steps - THEN assign the [task](/products/pro/tracking-and-tasks/tasks/) to a different person or team - THEN adjust deadlines - THEN trigger a webhook to an external system ### Combining multiple conditions Tallyfy lets you combine conditions with **AND** or **OR**, just like you'd explain rules to a colleague. #### Using AND logic AND means **ALL** conditions must be true. ``` IF [condition 1 is true] AND [condition 2 is true] THEN [do this action] ``` **Example:** IF the user selects urgent priority AND the amount is over $1000 THEN show the executive approval step #### Using OR logic OR means **AT LEAST ONE** condition needs to be true. ``` IF [condition 1 is true] OR [condition 2 is true] THEN [do this action] ``` **Example:** IF the client selects VIP service OR the order amount exceeds $5000 THEN show premium processing steps ### Mixing AND and OR logic Tallyfy evaluates conditions **left to right[^1]**: the exact order you add them. #### How evaluation works Given this rule: ``` IF [condition 1] AND [condition 2] OR [condition 3] THEN [do this action] ``` Tallyfy processes it step by step: 1. Evaluate condition 1 2. AND condition 2 with the result so far 3. OR condition 3 with the accumulated result The action triggers if: - Both condition 1 AND condition 2 are true, **OR** - Condition 3 is true by itself Tallyfy doesn't use operator precedence like programming languages (where AND would evaluate before OR). Conditions run in the order you add them. It's straightforward and predictable. #### Best practice for complex logic Don't cram everything into one massive rule. Break it up into multiple separate automation rules. This keeps your logic readable, easier to troubleshoot, and avoids confusion about evaluation order. You'll thank yourself later. ### How empty values affect conditions Empty or missing form field values can cause unexpected automation behavior. Here's how Tallyfy treats them: #### Empty field evaluation - **Text fields**: An empty field is "not equal" to any specific value - **Dropdowns**: No selection counts as different from any option - **Numbers**: Empty number fields don't match `greater_than` or `less_than` conditions - **Multiselect/file fields**: An empty list doesn't match any `contains` or `equals` check #### Common troubleshooting scenario **Problem**: A step shows up even though conditions don't seem true. **Likely cause**: You're using OR logic with "not equal" conditions. - "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, if ANY condition is true, the action triggers **Fix this by**: 1. Making the field required so it's never empty 2. Adding an explicit "is not empty" check 3. Using positive conditions ("equals") instead of negative ones ("not equals") [^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 are the THEN part of IF-THEN rules. They automatically assign people, adjust deadlines, toggle step visibility, reopen tasks, and fire webhooks when conditions are met. ## What are automation actions? Actions are the "THEN" part of [automation](/products/pro/documenting/templates/automations/) rules. When conditions are met, actions tell Tallyfy what to do - automatically. ### Why actions matter - **Cut manual work** - stop repeating the same assignments or toggling step visibility - **Stay consistent** - your [processes](/products/pro/tracking-and-tasks/processes/) run the same way, every time - **Prevent errors** - no human mistakes from routine decisions - **Move faster** - actions fire instantly, no waiting for someone to click buttons - **Enforce rules** - critical policies get followed automatically ### The five action types Tallyfy gives you five types of actions: #### Assignment actions Control who's responsible for [tasks](/products/pro/tracking-and-tasks/tasks/). - **Add assignees** - more people join a task without removing current assignees - **Replace assignees** - swap out everyone and assign new people - **Clear assignees** - remove all assignees from the task - You can also use an "Assignee Picker" form field to let someone else choose who gets assigned **Example:** `IF (Office Location) is "Toronto" THEN assign task "Mentor Meeting" to "Jane Doe"` [Learn more about assignment actions](/products/pro/documenting/templates/automations/actions/asignment-actions/) Related examples: - [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 Automatically adjust when tasks are due. - Set deadlines based on 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"` [Learn more about deadline actions](/products/pro/documenting/templates/automations/actions/deadline-actions/) Related 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 **re-open[^1]** completed [tasks](/products/pro/tracking-and-tasks/tasks/). That's their only function. Think approval loops - someone reviews work, requests changes, and the task reopens for edits. This only works on tasks already marked complete. Also, a status action can't reopen the same task that triggered it. **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/) Related examples: - [Multi-level approval loops](/products/pro/documenting/templates/automations/examples/multi-level-approval-loops/) #### Visibility actions Control whether steps appear or stay hidden. You'll likely use this type most. - Show or hide [tasks](/products/pro/tracking-and-tasks/tasks/) based on form answers - Create different process paths depending on conditions - Won't affect tasks that are already completed **Example:** `IF (Purchase Amount) is ">$10,000" THEN SHOW "Approval by CFO" step` [Learn more about visibility actions](/products/pro/documenting/templates/automations/actions/visibility-actions/) Related examples: - [Combined visibility and deadline rules](/products/pro/documenting/templates/automations/examples/combined-visibility-deadline-rules/) #### Webhook actions Fire an HTTP webhook to an external URL when conditions are met. This lets you connect Tallyfy automations to outside systems and services. [^1]: Status changes from completed back to in-progress, preserving task history and data - **[Conditionals](https://tallyfy.com/products/pro/documenting/templates/automations/conditionals/)**: Tallyfy's conditional logic lets workflows make automatic decisions using simple "IF X happens" rules based on form field answers, step statuses, and assignments. Processes adapt in real time without manual work or complex flowcharts. ## What's conditional logic? Conditional logic is the "IF" part of Tallyfy [automation](/products/pro/documenting/templates/automations/) rules - it lets your [processes](/products/pro/tracking-and-tasks/processes/) make decisions automatically. Think of it as teaching your workflow to handle different situations without you. :::tip[Simpler than flowcharts] Forget complex flowcharts. Tallyfy's conditional logic works like plain "IF X happens..." statements that anyone on your team can understand and update. ::: ### Why use conditionals? - **Automate decisions** - your workflow handles routine choices on its own - **Stay consistent** - the same rules fire every single time, no exceptions - **Cut manual work** - stop making predictable decisions yourself - **Adapt on the fly** - [processes](/products/pro/tracking-and-tasks/processes/) respond to what's actually happening ### Available condition types You can base conditions on: - [Form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) answers - including kickoff form fields and step form fields (e.g. "if budget exceeds $10,000") - Step status - completed, reopened, approved, rejected, acknowledged, or expired - Assignment status - whether a step has no one assigned (`not_assigned`) - **[Examples](https://tallyfy.com/products/pro/documenting/templates/automations/examples/)**: Tallyfy offers tested automation patterns for task assignment, workflow control, and deadline rules. Follow step-by-step instructions to route tasks and control process flow automatically. ## Automation examples Each example below covers a tested Tallyfy automation pattern with setup instructions. Pick one, follow the steps, and you're done. ### Assignment **[Assign to process requestor](/products/pro/documenting/templates/automations/examples/assign-step-to-requestor/)** Routes tasks back to whoever launched the process. No manual tracking. **[Dynamic member assignment from kick-off forms](/products/pro/documenting/templates/automations/examples/dynamic-member-assignment-from-kickoff/)** The process launcher picks team members via dropdown fields. Useful when different projects need different people. **[Service level-based task assignment](/products/pro/documenting/templates/automations/examples/service-level-assignment/)** Routes tasks by customer tier (Basic, Premium, Enterprise) so higher-tier customers automatically get the right support teams. ### Workflow control **[Exclusive choice (pick one path)](/products/pro/documenting/templates/automations/examples/exclusive-choice/)** The process follows one branch - never both. Office staff get IT setup; field workers get equipment training. Same template, different paths. **[Synchronization (wait for multiple approvals)](/products/pro/documenting/templates/automations/examples/synchronization/)** Every required sign-off must complete before the next step unlocks. **[Multi-level approval loops](/products/pro/documenting/templates/automations/examples/multi-level-approval-loops/)** A rejection sends the request back for fixes, then the approval chain restarts automatically. ### Time-based **[Countdown deadline automation](/products/pro/documenting/templates/automations/examples/countdown-deadline-automation/)** Counts backwards from a target date - agendas go out Monday, room bookings due Friday. **[Combined visibility and deadline rules](/products/pro/documenting/templates/automations/examples/combined-visibility-deadline-rules/)** Shows international shipping tasks only when needed AND sets their deadlines from arrival dates. Two automations working together. ### Quick reference - **Customer support routing** → [Service level-based assignment](/products/pro/documenting/templates/automations/examples/service-level-assignment/) - **Purchase approvals** → [Multi-level approval loops](/products/pro/documenting/templates/automations/examples/multi-level-approval-loops/) - **Event planning** → [Countdown deadline automation](/products/pro/documenting/templates/automations/examples/countdown-deadline-automation/) - **Project delegation** → [Dynamic member assignment](/products/pro/documenting/templates/automations/examples/dynamic-member-assignment-from-kickoff/) - **Compliance workflows** → [Synchronization](/products/pro/documenting/templates/automations/examples/synchronization/) For BPMN-based process patterns, see [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 let you add, replace, or clear task assignees in a workflow. Use form-based assignee picker fields for dynamic selection of who handles each task. ## Assignment actions explained Assignment actions change who's responsible for a [task](/products/pro/tracking-and-tasks/tasks/) when conditions are met in your workflow. You've got three options: - **Add assignees** - keeps everyone already assigned and adds new people - **Replace assignees** - clears current assignees and sets only the people you specify - **Clear assignees** - removes everyone, leaving the task unassigned You can assign specific members, guests, or groups. You can also use an Assignee Picker[^2] [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) so someone picks the assignee while filling out the form. If the picker field is empty, Tallyfy falls back to any manually specified assignees in the same action. :::warning[Watch out for unintended assignees] Tasks without assignees default to the process launcher[^1] unless the step's auto-assign launcher setting is turned off. If your automation uses **Add assignees**, the launcher stays assigned alongside your new people. Use **Replace assignees** to assign only who you want. ::: ### Examples **Example 1:** Assign based on location ``` IF (Office Location field) is "Toronto" THEN Add assignee "Jane Doe" to task "Mentor Meeting" ``` Jane gets added when someone selects Toronto. The original assignee stays on too. **Example 2:** Replace assignees by department ``` IF (Department field) is "Legal" THEN Replace all assignees for task "Contract Review" with "Legal Team" group ``` This completely replaces whoever was assigned. Only the Legal Team handles contract reviews for legal 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) ``` Someone picks the project manager in a form field. For urgent projects, that person becomes the sole approver. **Example 4:** Fixing unintended launcher assignment ``` Problem: Task has no assignees → launcher gets it → automation adds Kassie → both assigned Solution: Use "Replace assignees" instead of "Add assignees" to assign only Kassie ``` Unassigned tasks default to the launcher. "Add" keeps the launcher; "Replace" removes them. ![Assignment automation example in Tallyfy](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-assignment-automation-example.png) Every assignment action needs the **Apply to** setting - it tells Tallyfy which step should get the new assignments. Assignment actions won't apply to already-completed tasks. [^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/)**: Tallyfy's deadline actions automatically shift task due dates forward or backward based on IF-THEN rules. They reference a step's current deadline, another step's deadline, or a date from a form field while respecting your work week settings. ## Deadline actions Deadline actions adjust task due dates automatically when conditions in your automation rules are met. You can: - Shift a deadline forward or backward by a set amount (e.g. +3 days) - Base a deadline on another step's due date - Set a deadline from a date entered in a [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) Use the **Apply To** dropdown in your automation rule to pick which step's deadline changes. ### Examples of deadline actions Here's how deadline actions work in practice. **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 ``` **Example 2:** Set deadline from a form field date ``` IF (Project Scope field) is "Complex" THEN set deadline for step "Review Meeting" to (Client Kick-off Date field) + 5 days ``` The review meeting deadline lands 5 days[^1] after whatever date the user 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" ``` Final approval falls 2 days after the client feedback step was due. ![Deadline automation example showing step 13 deadline shift](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-deadline-automation-example.png) 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, pick where to start counting from: - **Current deadline** - add or subtract from the step's existing due date - **Another step's deadline** - build off a different step's deadline - **Date field value** - use a date someone entered in a form field Want Step B due 2 days after Step A? Set it as "+2 days from Step A's deadline." ::: :::note[How deadlines handle non-working days] Tallyfy checks your company's working days and hours (set in **Settings** > **Organization**). If a calculated deadline falls on a non-working day or outside work hours, Tallyfy **always pushes it forward** to the next working time. Never backward. A deadline that lands on Saturday moves to Monday morning (if Monday's a workday for you). Tallyfy uses calendar days for its calculations, then adjusts the result to fit your configured work week. It doesn't account for public holidays or individual time off - just the work week you've defined. See [Customize work week](/products/pro/settings/org-settings/how-to-adjust-task-deadlines-to-work-week/) to change these settings. **Coming soon**: Public holiday data for 200+ countries at [tallyfy.com/national-holidays](https://tallyfy.com/national-holidays/). A future release will skip national holidays automatically. ::: :::tip[Calendar-based vs relative deadlines] Tallyfy deadlines are relative to when the process starts[^2], not calendar-based. If you need deadlines on specific days (like every Monday): 1. **Weekly patterns** - schedule process launches on those days, then use relative deadlines 2. **Monthly patterns** - use scheduled launches on specific dates 3. **Accounting cycles** - consider separate templates for different deadline patterns 4. **Variable deadlines** - use date form fields to capture dates, then set deadlines relative to them ::: [^1]: Tallyfy calculates in calendar days, then adjusts to your configured working days if the result falls on a non-working day [^2]: Deadlines calculate from run creation time, not from a fixed calendar date - **[Status actions](https://tallyfy.com/products/pro/documenting/templates/automations/actions/status-actions/)**: Status actions in Tallyfy automatically re-open a previously completed task when a specific condition is met. They're ideal for approval rejections and feedback loops where work needs to go back a step for corrections. ## 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.** The target task must already be complete for this to work. If it's still open or hasn't started yet, nothing happens. They're 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. **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. **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. ![Example of a status action re-opening a completed step](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-statusactionexample.png) 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 open or not yet started. - A status action can't re-open the same task that triggered it - the target must be a different step. ::: - **[Automate hiding or showing tasks](https://tallyfy.com/products/pro/documenting/templates/automations/actions/visibility-actions/)**: Visibility actions use IF-THEN rules to show or hide workflow steps based on conditions like form field values or task completion. Hide steps by default and reveal them automatically as prior steps finish to enforce sequential order. ## Visibility actions explained Visibility actions let you **Show** or **Hide** specific steps based on conditions. They're smart switches - users see exactly what they need, when they need it. ### Examples **Example 1 - CFO approval for big purchases:** ``` IF (Purchase Amount field) is ">$10,000" THEN SHOW step "Approval by CFO" ``` The CFO approval step appears automatically for purchases over $10k. **Example 2 - Skip irrelevant reviews:** ``` IF (Customer Type field) is "Small Business" THEN HIDE step "Enterprise Security Review" ``` Small business customers skip the enterprise security review entirely. **Example 3 - Adapt to user input:** ``` IF (Application Type field) is "Mortgage" THEN SHOW steps "Credit Check", "Property Valuation", and "Underwriting" ``` Selecting "Mortgage" reveals all mortgage-specific steps at once. Here's what it looks like in action: ![Task completion triggering visibility automation in Tallyfy](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-task-completion-example-automations.png) 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 when building the [template](/products/pro/documenting/templates/) - toggle **Hide by default** in the step settings. - A **Hide** action makes steps disappear based on conditions. - A **Show** action reveals hidden steps when conditions are met. ::: :::warning[Hidden steps can't be completed] Hidden steps have an internal status of `auto-skipped` and can't be completed. Any automation checking "if step is complete" on a hidden step won't trigger - unless another rule makes that step visible first. Only create completion-based automations for steps users can actually see. You can also [manually show or hide steps](/products/pro/tracking-and-tasks/tasks/manually-show-hide-tasks/) using the three-dot menu on any task. ::: :::note[Default behavior: parallel execution] Procedure templates in Tallyfy show all steps at once by default. People can work on them in any order[^1]. To enforce sequential order, hide steps initially and use **Show** automation rules to reveal them when previous steps complete. ::: ### Hiding tasks by default in a template All tasks show up when someone launches a [procedure template](/products/pro/documenting/templates/). To keep certain tasks hidden until the right moment: Hidden steps stay out of sight until a **Show** automation brings them back. ### Enforcing sequential task order Sometimes Task B shouldn't start until Task A is done. You can force tasks to appear in sequence using hidden tasks and **Show** visibility actions in your [automations](/products/pro/documenting/templates/automations/)[^2]. The result: - Process starts - only Task A shows up - Complete Task A - Task B appears - Complete Task B - Task C appears You can chain as many tasks as you need this way. [^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/)**: Conditionals are the IF part of Tallyfy automations. They check whether step statuses or form field values match your criteria and trigger actions automatically. ## How conditionals work Conditionals in Tallyfy [automations](/products/pro/documenting/templates/automations/) are "if this, then that" rules. They watch for specific events, like a [task](/products/pro/tracking-and-tasks/tasks/) that's completed or a form answer matching a value, and trigger actions automatically. The **Condition** is your "IF" part. What you can check depends on whether you're looking at a step's status or a form field's value. ### Step-based conditions These check a step's status within your workflow. Every step type also supports **reopened** and **not assigned** conditions. - **Regular step** (and email step): Is it **completed**? (IF Step 1 Is completed THEN...) - **Approve/reject step**: Is it **approved** or **rejected**? (IF Approval Step Is rejected THEN send it back) - **Expiry step**: Is it **acknowledged** or **expired**? - **Any step with a deadline**: Is the **deadline overdue**? Fires once per process when the deadline passes and the task still isn't done. This one is built but **not released yet**, so it isn't available in the visual builder or through the API. Until it ships, build escalations using the **expiry step** condition above. See [escalating overdue tasks](/products/pro/tracking-and-tasks/tasks/task-escalation-for-overdue-items/) for the step by step method. ### Form field conditions You can check what people enter in [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) - both on steps and in kick-off forms - and act on their answers. Each field type supports different operators: - **Short text, long text, or file upload**: **Contains**, **Does not contain**, **Is empty**, **Is not empty**. Short text fields with numeric validation also get **Greater than** and **Less than**. - **Dropdown**: **Is**, **Is not**, **Contains**, **Does not contain**, **Any of**, **Greater than**, **Less than** - **Radio buttons or checkboxes (multi-select)**: **Is**, **Is not**, **Contains**, **Does not contain**, **Any of** - **Table**: **Contains** (can target a specific column) - **Date**: **Contains**, **Does not contain**, **Is empty**, **Is not empty** - **Assignee form field**: **Is empty**, **Is not empty** Someone selects "High Priority"? Route it to management. Budget over $10,000? Trigger an approval step automatically. :::note[Combining multiple conditions] Combine conditions using AND/OR logic (see [Logic operations](/products/pro/documenting/templates/automations/logic-explained/)) to create precise triggers. ::: ### Examples - **[Automatically assign a step to the original process requestor](https://tallyfy.com/products/pro/documenting/templates/automations/examples/assign-step-to-requestor/)**: Capture who started a process using an Assignee Picker field, then auto-assign a final step to that person through a template automation rule. Capture who kicked off a process and automatically route a later step back to them - perfect for sending payment confirmations, completed documents, or results to the original requestor. ## Use case You're running a purchase request process: 1. Sarah from marketing submits a request for new software. 2. The request goes through approvals and finance. 3. Your accountant uploads the payment proof. 4. Sarah should automatically get that proof - without anyone remembering who started the request. How do you capture Sarah's identity at the start and notify her at the end? ## Prerequisites * An existing [procedure template](/products/pro/documenting/templates/). * Familiarity with [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) - especially the **Assignee Picker** field type. * A basic grasp of [template automations](/products/pro/documenting/templates/automations/). ## Setting up this automation ## How it works at runtime When someone launches your process: 1. Sarah fills out the kick-off form and selects herself in the assignee picker field. 2. The process moves through all its steps - approvals, processing, everything. 3. Tallyfy evaluates your automation rule and checks whether the assignee picker field was filled in. 4. Since it's not empty, the automation fires. 5. The **Replace Assignees** action swaps whoever was originally assigned to the final email step with Sarah from the picker field. 6. Because you set the step type to **Email Auto-Send**, Tallyfy sends the email automatically on the due date. No manual work needed. Sarah gets her payment proof without anyone having to remember she started this process three days ago. ## Related concepts * [Assignee picker form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/#assignee-picker) - The field type that drives this pattern * [Automation Actions: Assignment](/products/pro/documenting/templates/automations/actions/#assignment-actions) - Other ways to change task assignments * [Using variables](/products/pro/documenting/templates/variables/) - Pull data from earlier steps into 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 automatically sends an email on the due date and auto-completes itself - **[Combined visibility and deadline rules](https://tallyfy.com/products/pro/documenting/templates/automations/examples/combined-visibility-deadline-rules/)**: Combine visibility and deadline automations so steps appear only when conditions are met, with deadlines based on shipment types, contract categories or customer tiers. Combine visibility and deadline automations in Tallyfy so steps only appear when they're relevant - and arrive with the right due date already set. ## When you'd use this - **Shipping** - International orders need customs checks with deadlines tied to arrival dates. Domestic orders skip the step entirely. - **Contract renewals** - Enterprise contracts trigger legal review 30 days before expiration. Standard contracts skip it. - **Event planning** - Catering requested? That task appears with a 14-day countdown to event day. - **Customer onboarding** - Premium customers get expedited setup steps with 24-hour turnarounds. ## How to set it up ## Examples ### Contract renewal with type-specific deadlines **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) ``` Enterprise contracts trigger legal review 30 days before expiration. Standard contracts skip the step entirely. ### Event planning with optional services **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. Catering needed? It'll appear with a 14-day countdown. ### Support 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) ``` Critical issues that first-line support can't resolve escalate to senior engineers with a 2-hour SLA[^1]. ## Advanced patterns ### Multiple conditions on one step You can use AND/OR logic to combine conditions. Tallyfy supports both operators: ``` // 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 - more time IF (Shipping Method field) is "Standard" THEN Set deadline for "Export compliance check" to 3 days after process launch ``` ### Cascading deadlines One task's deadline can reference another task's deadline: ``` // 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 references first step's deadline IF (Requires Inspection field) is "Yes" THEN Show "Inspection report filing" AND Set deadline to 1 day after "Quality inspection" deadline ``` ## Best practices - **Match your conditions** - If a step shows for "International" shipments, its deadline should trigger on the same condition. - **Set default deadlines** - Hidden steps should still have reasonable defaults in case someone manually shows a step. - **Test edge cases** - What happens if a date field's empty? Or a condition changes mid-process? Find out before your users do. - **Name steps clearly** - "Premium setup verification" beats "Step 3," especially for conditional steps. :::tip[Rule evaluation order[^2]] Tallyfy evaluates all applicable rules when conditions change. At process launch, steps with "Show" actions are hidden by default, then rules run to determine which should appear. Deadline rules can reference the same form fields as visibility rules. ::: [^1]: Service Level Agreement - a contractual commitment to respond within specified time [^2]: Rules execute in position order. At process launch, steps with "Show" actions are hidden first, then all rule conditions are evaluated. - **[Countdown deadline automation](https://tallyfy.com/products/pro/documenting/templates/automations/examples/countdown-deadline-automation/)**: Set up automated countdown deadlines that work backwards from important dates so preparation tasks are always completed on time. Tallyfy lets you set [task](/products/pro/tracking-and-tasks/tasks/) deadlines that count backwards from a target date. Your meeting agenda can be automatically due 1 day before the meeting. That's how preparation tasks always finish before the critical date arrives. ## When to use countdown deadlines - **Meeting prep** - reminders 1 day before scheduled meetings - **Event planning** - setup tasks due 2 weeks before the event - **Launch coordination** - marketing materials due 1 week before launch - **Contract renewals** - start discussions 30 days before expiration - **Compliance** - submit reports 5 days before regulatory due dates You're working backwards from a fixed date. Everything lands on time. ## How to create countdown deadline automations ## Real-world examples ### Sales funnel **Kick-off form field**: "Scheduled meeting date" ``` IF (Scheduled Meeting Date) exists THEN Set deadline for "Complete prospect research" to 3 days before (Scheduled Meeting Date) ``` ``` IF (Scheduled Meeting Date) exists THEN Set deadline for "Send meeting agenda" to 1 day before (Scheduled Meeting Date) ``` ``` IF (Scheduled Meeting Date) exists THEN Set deadline for "Meeting day checklist" to 2 hours before (Scheduled Meeting Date) ``` Valid deadline units are minutes, hours, days, weeks, and months. ### Podcast publishing **Kick-off form field**: "Podcast launch date" ``` IF (Launch Date) exists THEN Set deadline for "Upload final audio" to 1 week before (Launch Date) ``` ``` IF (Launch Date) exists THEN Set deadline for "Create social media posts" to 3 days before (Launch Date) ``` ``` IF (Launch Date) exists THEN Set deadline for "Final quality check" to 1 day before (Launch Date) ``` ### International shipping **Step 1 fields**: Location (dropdown) and Expected arrival date (date field) ``` IF (Location) is "International" THEN Show "Verify customs documentation" ``` ``` IF (Location) is "International" THEN Set deadline for "Verify customs documentation" to 1 week before (Expected Arrival Date) ``` International shipments won't get stuck at customs. ## Advanced patterns ### Multiple deadlines from one date Create separate automation rules that all reference the same date field: ``` IF (Contract End Date) exists THEN Set "Initial renewal discussion" to 60 days before (Contract End Date) ``` ``` IF (Contract End Date) exists THEN Set "Prepare renewal proposal" to 45 days before (Contract End Date) ``` ``` IF (Contract End Date) exists THEN Set "Send renewal offer" to 30 days before (Contract End Date) ``` Each rule is a separate automation - they'll all fire independently based on the same date. ### Conditional countdown deadlines Different lead times based on other field values: ``` 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 adjustment Tallyfy adjusts deadlines to fall within your org's configured working hours[^2]. If a calculated deadline lands on a non-working day, it shifts to the next available working day and time. ## Tips - **Add buffer** - use 2 days before instead of 1 for critical tasks - **Name tasks clearly** - include timing like "Send agenda (1 day before meeting)" - **Require date fields** - if countdown deadlines depend on a date, make that field required - **Set fallback deadlines** - add default deadlines on steps in case date fields are left empty - **Test around weekends** - verify deadlines calculate correctly near non-working days :::tip[When deadlines recalculate] Tallyfy recalculates countdown deadlines at two key points: 1. When the process launches (if the date field is in the kick-off form) 2. When you complete a step that contains the date field Your deadlines stay accurate based on these triggers. ::: [^1]: Pre-launch form that captures initial data before a process starts in Tallyfy [^2]: Working hours configured in **Settings** > **Organization**, typically Monday-Friday business hours - **[Decision with waiting step](https://tallyfy.com/products/pro/documenting/templates/automations/examples/decision-wait-continue/)**: Use three automations together for decision-wait-continue patterns. YES skips the wait, NO shows the waiting step, and a third fires when waiting completes to show the next step. ## Decision with waiting step This pattern requires three automations, not two. It handles "Is something ready?" - either proceed immediately or wait until it is. ### The pattern - **YES** - skip waiting, go directly to the next step - **NO** - show a waiting step, then continue when it's done Most people create two automations (one for YES, one for NO) and stop there. That's the mistake. ### Example: payment confirmation 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) ### All three automations **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 wait, 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 ``` Haven'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 ``` That's the critical piece. When the waiting step finishes, it reveals the confirmation step. :::warning[Common mistake] Without automation 3, the confirmation step stays hidden forever after the waiting step completes. The NO path dead-ends. ::: ### Why you need all three Here's 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 closes the loop on the NO path. - **[Exclusive choice](https://tallyfy.com/products/pro/documenting/templates/automations/examples/exclusive-choice/)**: Tallyfy's exclusive choice pattern lets you branch a single process into one of several paths based on a form field condition. Use a radio button to select an employee role and automatically show only the relevant onboarding steps for that role. ## Exclusive choice - pick one path Exclusive choice automation sends your process down exactly **one** path from multiple options based on a condition. It's the "pick A or B, never both" pattern. ![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) *(Choose Path A OR Path B - not both)* 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 and runs only that rule. One path. That's it. ### Example - different onboarding steps by role Say you're onboarding new employees. Field workers need safety training and equipment setup. Office workers need IT access and desk assignments. Same [process](/products/pro/tracking-and-tasks/processes/) - completely different steps. Add a step asking for the employee's role using a **Radio Button** [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) (radio buttons only allow *one* selection). ![Role selection step with radio button form field](https://screenshots.tallyfy.com/tallyfy/pro/desktop-light-role-selection.png) Then create two [automation](/products/pro/documenting/templates/automations/) rules using Visibility Actions[^1]: - **Rule 1:** ``` IF (Role field) is "Field worker" THEN SHOW steps [List of steps specific to Field workers] ``` ![Automation rule showing field worker visibility condition](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] ``` ![Automation rule showing office worker visibility condition](https://screenshots.tallyfy.com/tallyfy/pro/desktop-light-office-worker-exclusive-choice.png) The Role field can only hold *one* value - so only *one* rule fires. Field workers see safety protocols and equipment checklists. Office workers see IT setup and workspace prep. Never both. The key: use conditions that can't be true at the same time (like radio button options). Tallyfy picks the right path automatically. [^1]: Actions that show/hide steps based on conditions, part of Tallyfy's automation engine - **[Dynamic member assignment from kick-off forms](https://tallyfy.com/products/pro/documenting/templates/automations/examples/dynamic-member-assignment-from-kickoff/)**: Use assignee picker fields in kick-off forms so process launchers can pick who handles each task. Automation rules then assign those chosen people automatically. Assignee picker fields in kick-off forms[^1] let the person launching a process choose who handles specific [tasks](/products/pro/tracking-and-tasks/tasks/). Tallyfy's automation rules[^2] then assign those chosen people automatically - no hard-coded assignments needed. ## When to use this - A coordinator launches client onboarding and picks which account manager handles that client - A manager starts a new hire process and selects the right HR specialist (Sarah for tech hires, Mike for sales) - Someone requests a purchase approval and picks their assistant to gather documentation Task assignment stays flexible. The launcher decides who gets what. :::tip[Self-service shortcut] If you only want to auto-assign the public kickoff submitter (a guest) to a field, mark the Assignee Picker field as **Default to guest** in the kickoff form settings. No automation rule needed - the submitter gets assigned on launch automatically. Use the automation patterns below when you need different assignees per field, conditional logic, or fallbacks. ::: ## Setting it up ## Advanced patterns ### Combining with other conditions Mix assignee pickers with other form field conditions using AND/OR logic: ``` IF (Priority field) is "Urgent" AND (Senior Manager field) is not empty THEN Replace assignee(s) for "Final Approval" with (Senior Manager field) ``` Urgent requests go to the senior manager you picked. Regular ones follow the normal approval chain. ### Multiple pickers for different stages Use separate assignee picker fields when different process stages need different people: - **Initial stages**: Assigned to the "Project Lead" picker selection - **Middle stages**: Handed to the "Technical Expert" picker selection - **Final stages**: Goes to the "Quality Reviewer" picker selection Each picker controls its own set of steps independently. :::tip[Best practices] - Mark assignee picker fields as required if tasks can't proceed without someone assigned - Use plain labels - don't make people guess what "SME Resource" means - Add help text explaining what each role will do - Test with real scenarios before going live - launch test processes and verify the right people get assigned ::: ## 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 - **[Multi-level approval loops](https://tallyfy.com/products/pro/documenting/templates/automations/examples/multi-level-approval-loops/)**: Build multi-level approval chains where rejections automatically reopen earlier steps for corrections. Use approve/reject task types and status action rules for sequential sign-offs with conditional routing and parallel approvals. Multi-level approval loops reopen earlier steps automatically when someone rejects. Rejections bounce work back for corrections - no manual tracking needed. ## When to use this Any workflow needing sequential sign-offs: - **Financial approvals** - Purchase requests through manager, finance, then executive - **Content publishing** - Draft, editor review, legal review, final sign-off - **Contract management** - Department head, legal, CFO, CEO - **Quality control** - Inspection, supervisor check, quality manager sign-off Rejection at any level bounces work back to whoever needs to fix it. ## Creating the workflow Here's how the approval chain flows: [Diagram removed for brevity] **Key points:** - Every rejection re-opens the creation task - Later approvals won't appear until earlier ones pass - [visibility rules](/products/pro/documenting/templates/automations/actions/visibility-actions/)[^1] control this - COO rejection can re-open multiple steps at once ## Advanced approval patterns ### Conditional approval routing Route approvals based on field values like amount thresholds: ``` IF (Purchase Amount) is greater than $50,000 AND (Manager review) is Approved THEN Show "Board approval required" ``` ### Parallel approvals When multiple teams need to review at the same time, use parallel approvals: [Diagram removed for brevity] **Key points:** - All three approvals trigger at once after initial review - The final step waits until ALL parallel approvals complete - Any single rejection sends everything back to start Set this up with [visibility rules](/products/pro/documenting/templates/automations/actions/visibility-actions/): ``` IF (Initial review) is Completed THEN Show "Legal approval" AND Show "Compliance approval" AND Show "Finance approval" ``` Then gate the final step on all three approvals: ``` IF (Legal approval) is Approved AND (Compliance approval) is Approved AND (Finance approval) is Approved THEN Show "Final implementation" ``` ### Escalation paths If approvals get stuck: 1. Set a deadline on the approval step 2. Create an escalation step assigned to senior management 3. Add an expiring step dated a little after the approval deadline, then trigger the escalation when that step expires. Deadline automations cannot start anything, they only change a deadline, so the expiring step is what acts as the clock ## Best practices - **Rejection reasons** - Add comment fields so reviewers explain what needs fixing - **Notifications** - Turn on email notifications so people know when tasks bounce back - **Loop limits** - After 3 rejections, escalate to a meeting instead - **Step instructions** - Tell reviewers the exact criteria you're looking for - **Audit trail** - Tallyfy tracks every approval and rejection automatically :::note[Re-open behavior] When Tallyfy re-opens a task: - Status changes from "Completed" back to "In progress" - Original assignees get notified - All previously entered data stays intact - The task reappears in each assignee's task list ::: ## Example: property listing approval Here's how a real estate agency handles listing approvals: [Diagram removed for brevity] **How it works:** - Marketing rejection gives the agent specific feedback on photos - Compliance issues notify both agent and manager - Agents know exactly what to fix. No vague "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/)**: Automatically notify the person who launched a process when it completes using an Assignee Picker field and an Email Auto-Send automation rule. ## Notify the requestor when a process completes Capture who launched a process using an Assignee Picker field, then use an automation rule to send them a notification when it's done. The person who started the process always knows the outcome - no chasing required. ### Common use cases - **Service requests** - let employees know their IT, HR, or facilities requests are done - **Approval workflows** - tell requestors whether they've been approved or rejected - **Order processing** - send confirmations when everything ships - **Document processing** - deliver finished documents to whoever submitted them ### Prerequisites - Admin or Standard member role to edit templates - Familiarity with [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) and [automations](/products/pro/documenting/templates/automations/) ### Setting up requestor notification ### Alternative approaches #### Multiple notification recipients 1. Add multiple Assignee Picker fields (e.g. "Requestor" and "CC Recipients") 2. Create separate notification steps for each group 3. Set up automation rules to route each notification correctly #### Conditional notifications based on outcomes 1. Add a dropdown field for process outcome ("Approved", "Rejected", "Pending") 2. Create a notification step per outcome 3. Use conditional visibility automations so only the right notification fires #### Webhooks for advanced notifications 1. Add a webhook automation on the final step completion 2. Connect it to middleware (Zapier, Make, Power Automate) to: - Send formatted HTML emails - Pull attachments from other systems - Trigger SMS or Slack messages ### Best practices - **Clear labeling** - name your Assignee Picker field so people know exactly what to pick - **Test first** - always run a test process before going live - **Include context** - use variables to pack notifications with useful details - **Set timing carefully** - if your final data needs processing, add a buffer before the notification deadline ### Troubleshooting **Notification not sending?** - Check the Assignee Picker field has someone selected - Verify the automation rule is active - Confirm the step type is "Email Auto-Send" - it shouldn't be a regular task - Email Auto-Send steps trigger when the deadline passes **Wrong person getting notified?** - Double-check you selected the right Assignee Picker field in the automation - Verify what users are selecting in the form **Missing data in the notification?** - Check that your variable aliases match the actual form field aliases - Referenced fields must be filled before the notification step fires - they can't be empty ### Example: IT service request completion 1. **Kick-off form** - three fields: - Assignee Picker: "Select your name" - Request type dropdown - Description text area 2. **Process steps**: - IT reviews the request - IT completes the work - IT uploads documentation 3. **Final notification step**: - Type: Email Auto-Send - Deadline: 30 minutes after "Upload documentation" completes - Content: request details plus attached docs - Automation: assigns the step to whoever launched the process - **[Synchronization](https://tallyfy.com/products/pro/documenting/templates/automations/examples/synchronization/)**: Use the AND operator in Tallyfy automations to wait for multiple approvals or conditions before moving forward. All connected conditions must be true before the next steps become visible. ## Automation example - synchronization (wait for multiple things) Use the **AND** operator in Tallyfy [automations](/products/pro/documenting/templates/automations/) to make your process wait for several approvals before moving forward. When you connect conditions with **AND**, *all* of them must be true before anything happens. ![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)* Think of it like needing two keys to open a vault - you can't proceed with just one. ### Example - wait for HR and manager approval Say 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 approve. 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. ![HR and manager approval tasks in an employee onboarding process](https://screenshots.tallyfy.com/tallyfy/pro/desktop-light-hrmanager-approval-synchronization.png) Then 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] ``` ![Automation rule checking both HR and manager approval status](https://screenshots.tallyfy.com/tallyfy/pro/desktop-light-hrmanager-automation-synchronization.png) The **AND** between conditions is your synchronization point. Onboarding steps stay hidden until both approvals come through. No more chasing people or wondering who approved what. - **[Service level-based task assignment](https://tallyfy.com/products/pro/documenting/templates/automations/examples/service-level-assignment/)**: Tallyfy automations route tasks to different team members based on customer service tiers. IF-THEN rules on kick-off form fields assign enterprise clients to senior specialists and free-tier users to general support groups. Use Tallyfy [automations](/products/pro/documenting/templates/automations/) to route [tasks](/products/pro/tracking-and-tasks/tasks/) to different team members based on customer service levels. IF-THEN rules on kick-off form fields let you match the right expertise to each customer's tier automatically. ## When you'd use service-based routing - **Tiered support** - Enterprise customers get a dedicated team; free users get standard support - **Sales processes** - High-value deals go to senior closers - **Professional services** - Complex projects get senior consultants; simple ones go to junior staff - **Subscription management** - Enterprise onboarding gets your best people; free trials go to anyone ## Setting up service-based assignment ### Basic service level routing Here's a real example - routing tasks based on service packages. **Scenario**: You're onboarding clients, and Platinum customers need your best account manager. 1. **Add a service selection field to your kick-off form[^1]**: - Field type: Dropdown or Radio - Options: "Basic", "Professional", "Platinum" - Label: "Select service package" 2. **Create assignment rules for each level**: **Rule 1: Platinum service** ``` IF (Service Package field) is "Platinum" THEN Replace Assignees for "Prepare proposal" with "Sarah Chen" AND Replace Assignees for "Account setup" with "Sarah Chen" ``` **Rule 2: Professional service** ``` IF (Service Package field) is "Professional" THEN Replace Assignees for "Prepare proposal" with "Mike Johnson" AND Replace Assignees for "Account setup" with "Mike Johnson" ``` **Rule 3: Basic service** ``` IF (Service Package field) is "Basic" THEN Replace Assignees for "Prepare proposal" with "Support Team" group AND Replace Assignees for "Account setup" with "Support Team" group ``` ### Advanced patterns #### Workload-balanced assignment Don't pile everything on one person - assign to a group instead: ``` IF (Service Package field) is "Platinum" THEN Replace Assignees for all account management tasks with "Senior Account Managers" group ``` When you assign to a group, Tallyfy distributes work across its members. #### Multi-criteria assignment Combine multiple conditions when service level alone isn't enough: ``` IF (Service Package field) is "Enterprise" AND (Industry field) is "Healthcare" THEN Replace Assignees for "Compliance review" with "Healthcare Specialist Team" ``` This matches expertise to both customer tier AND industry. #### Progressive expertise escalation Higher tiers often need extra approval steps: ``` 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 ``` ## Example: technical support tiers Here's how a support team can route tickets by customer tier. **Kick-off form fields**: - Customer tier (dropdown): "Free", "Starter", "Growth", "Enterprise" - Issue type (dropdown): "Bug", "Feature Request", "Integration Help" **Automation rules**: 1. **Free tier - community support**: ``` IF (Customer Tier) is "Free" THEN Assign "Initial response" to "Community Managers" AND Update deadline to 48 hours from now ``` 2. **Starter tier - standard support**: ``` IF (Customer Tier) is "Starter" THEN Assign "Initial response" to "Tier 1 Support" AND Update deadline to 24 hours from now ``` 3. **Growth tier - priority support**: ``` IF (Customer Tier) is "Growth" THEN Assign "Initial response" to "Tier 2 Support" AND Update deadline to 4 hours from now ``` 4. **Enterprise - dedicated support**: ``` IF (Customer Tier) is "Enterprise" THEN Assign "Initial response" to "Enterprise Success Team" AND Update deadline to 1 hour from now AND Show "Executive escalation" step ``` Each customer gets what they're paying for. Your team stays organized. ## Best practices - **Clear service definitions** - Document what each tier includes so your team knows the expectations - **Backup assignments** - Use groups instead of individuals so coverage doesn't break during vacations - **Time zones** - Enterprise customers in different regions shouldn't wait for your local team to start - **Monthly review** - Check assignment patterns to spot uneven workload before it causes burnout - **Transparent routing** - Tell customers upfront how their tier affects response speed [^1]: Kick-off form - collects data before launching a process, used by automation rules to route tasks and set values ### Snippets - **[Use snippets](https://tallyfy.com/products/pro/documenting/templates/snippets/how-can-i-use-snippets-to-simplify-workflow-in-tallyfy/)**: Tallyfy snippets let admins create reusable text blocks like disclaimers or contact info that any member can insert into template steps, task descriptions, and comments. Write standard content once through the References panel and update it everywhere from a single source. ## Creating and using snippets 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 [documents](/products/pro/documenting/documents/). Open the **References** panel in any rich text editor and select the snippet you want. Think compliance disclaimers, contact info, or standard instructions. Write it once, reuse it everywhere. ### Who can create and manage snippets? - **Admin** members can create, edit, and delete snippets for the whole organization - **All other members** can insert existing snippets wherever they're editing rich text ### Creating snippets (Admin only) ![Tallyfy snippet creation screen](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-create-snippet1701483433378.png) ### Managing existing snippets (Admin only) On the Snippets settings page, you can: - View all snippets in a searchable, sortable table - Edit any snippet - changes appear when content is next viewed[^1] - Delete outdated snippets - Control whether a snippet is visible in public templates via the **Visible in Public Templates** checkbox ### Inserting snippets into text ![Inserting a snippet into a template in Tallyfy](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-insert-snippet-in-template-example.png) ### Where can I use snippets? Anywhere you see Tallyfy's rich text editor: - Template descriptions and step descriptions - Guidance text for [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) - Launch instructions shown before starting a process - Task comments - [Document template](/products/pro/documenting/documents/) content ### Embedding template references You can also link to entire templates from the same References panel. Useful when your workflow mentions another process - embed a reference instead of copying content. ### Tips for snippets **Name them descriptively.** "Legal disclaimer for contracts" beats "Legal text 1." **Keep them focused.** A three-paragraph warranty disclaimer works. An entire employee handbook doesn't. **Single source of truth.** If a support phone number appears in 12 processes, make it a snippet. Update once. **Review periodically.** Check quarterly that they're still current and relevant. [^1]: Snippet content is fetched fresh when viewed, so edits propagate on next view. Running processes retain the content from when they were launched. ### Variables - **[Insert variables](https://tallyfy.com/products/pro/documenting/templates/variables/how-can-i-use-insert-variables-in-tallyfy/)**: Tallyfy lets you insert dynamic variables into step titles and descriptions by clicking the { } button. Pull form field data from earlier steps into later ones so workflows stay personalized without manual retyping. ## Using and inserting variables Click the **{ }** button in any step title or description to insert data from earlier form fields. That's the core of it. Variables automatically pull information from one step into another within your [process](/products/pro/tracking-and-tasks/processes/). They turn generic workflows into personalized ones. Someone fills out a [form field](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) in step 1, and you can display that exact value in steps 5, 10, or 20 - no retyping needed. ### Requirements - 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 (your data source) - A later step where you want that data to appear ### How variables work - **Source**: The form field where someone enters information - **Target**: Any step title or description where you want that info to appear - **Format**: Variables use `{{field-alias}}` syntax in double curly brackets When someone fills in the source field, that value appears wherever you've placed the variable. Change the source? It updates everywhere instantly. :::tip[Using variables for guest assignment] Capture a guest email in the kick-off form, then use that variable in later step assignments to dynamically assign tasks to external people. Example: Kick-off form asks "Client email?" - later step assigns task to `{{client-email}}` - that client gets the task automatically. **Note**: You'll need 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 When you click **{ }**, you'll see two categories: * **Kick-off form fields**: Data entered when someone launches the process * **Form fields from previous steps**: Data entered in steps that come *before* the current one Tallyfy also supports built-in system variables[^1]: * `{{current-task-id}}` - the unique ID of the current task * `{{current-process-id}}` - the unique ID of the running process * `{{DATE}}` - the date the process was launched * `{{TEMPLATE_NAME}}` - the name of the template :::note[Not all field types support variables] File upload, table, and assignee form fields can't be used as variable sources. Only text, textarea, radio, dropdown, multiselect, and date fields appear in the variable picker. ::: ### Adding variables to step titles ### Adding variables to step descriptions ### During process execution 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 3. Later steps with variables show the actual values instead of `{{field-alias}}` placeholders 4. Update the source field and the change flows through everywhere ### Common examples #### Task titles with context - "Get approval for Project: `{{project-name}}`" - "Review document for Client: `{{client-name}}`" - "Schedule meeting with `{{department-name}}` lead" #### Specific instructions - "Review the proposal for `{{client-name}}`, focusing on `{{focus-area}}`." - "Call `{{customer-name}}` at `{{phone-number}}` to discuss order `{{order-number}}`." - "Prepare the `{{document-type}}` based on the request from `{{requesting-department}}`." #### Auto-naming processes Variables pair well with [auto-naming](/products/pro/tracking-and-tasks/processes/edit-processes/how-can-i-auto-name-a-process-in-tallyfy/). Your processes name themselves based on form data: - "Onboarding - `{{employee-name}}` - `{{department}}`" - "Support Ticket - `{{ticket-number}}` - `{{client-name}}`" No more "Process #12345" confusion. ### Tips for good variable usage - Name your [form fields](/products/pro/tracking-and-tasks/tasks/what-are-form-fields-in-tallyfy/) clearly - "Customer Name" beats "Field 1" - Test-run your template before going live - Think about empty fields - if someone skips "Department," will "Contact the lead" still make sense? - Surround variables with context: "Contact `{{name}}` at `{{phone}}`" not just "`{{name}}` `{{phone}}`" ### Combining variables with conditional logic One template can handle multiple scenarios when you combine variables with [conditional automations](/products/pro/documenting/templates/automations/conditional-visibility-guide/). **Example - Region-specific checklists**: 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 does the job of four. **Dynamic email notifications** can also use variables: - Subject: "Action required: `{{task-name}}` for `{{client-name}}`" - Body: "The `{{document-type}}` for `{{project-name}}` needs your review by `{{due-date}}`" :::tip[Variables + conditional logic = smart templates] Combining variables with [conditional automations](/products/pro/documenting/templates/automations/conditional-visibility-guide/) lets you create templates that adapt based on the data entered - no need for multiple similar templates. ::: ### Troubleshooting broken variables **Variables showing as raw text?** (like seeing `{{client-name}}` instead of "Acme Corp") This means the variable lost its connection to the source field. Fix it: 1. Delete the broken variable text 2. Click the **{ }** button again 3. Re-select the field from the dropdown 4. Save your changes Common causes: - Renaming or deleting the source form field - Copying template content from another template - Manually typing `{{...}}` instead of using the insert button - Template import/export operations that break references Always use the **{ }** button rather than typing variable syntax manually. ### Variables in URLs - hidden character issue :::caution[URLs with variables may contain hidden characters] The rich text editor may insert invisible UTF-8 BOM characters[^2] (%EF%BB%BF) around variables in URLs, breaking the links. **Problem**: `https://example.com?id=%EF%BB%BFvalue%EF%BB%BF` instead of `https://example.com?id=value` **Fix**: Build your complete URL in a plain text editor first (including variable placeholders like `https://example.com?id={{record-id}}`), then paste it into the step description as a single unit. Test the link in a launched process. ::: [^1]: System variables like current-task-id and current-process-id return 32-character hash IDs used internally by Tallyfy's database [^2]: Byte Order Mark characters (U+FEFF) used for encoding detection but can corrupt URL parameters ### Settings - **[Organization settings](https://tallyfy.com/products/pro/settings/org-settings/)**: Tallyfy's organization-wide settings let administrators control member permissions, billing, branding, integrations, and admin policies for every team member across the company. ## Organization-wide settings Organization settings control how Tallyfy works for your entire company. They affect all team members. Only **Administrator** users can access and change these settings. You'll find controls for member permissions, billing, branding, integrations, and admin policies here. - **[Personal settings](https://tallyfy.com/products/pro/settings/personal-settings/)**: Tallyfy's personal settings let you customize your profile, password, email notifications, language, time zone, and date format without affecting anyone else in your organization. ## Managing personal Tallyfy settings Personal settings control your own Tallyfy experience - profile details, password, email notifications, language, time zone, and date format. Changes here don't affect other members in your organization. - **[Billing](https://tallyfy.com/products/pro/settings/billing/)**: Tallyfy bills per seat through Recurly. You commit to full and light seats, pre-pay for your term, and manage seats, payments, and invoices from Settings then Billing. Invoiced and multi-entity accounts are billed through Xero. ## Billing overview Go to **Settings > Billing** to manage your subscription, seats, payment methods, and invoices. Tallyfy bills per seat and uses Recurly as its billing partner for card payments. Invoiced and multi-entity accounts are billed through Xero. The Billing section covers: * **Plan and seats** - your committed full and light seats, and current usage * **Payment management** - update cards and billing details * **Invoice history** - past invoices and payment records * **Add-ons and credit** - Analytics and pre-paid usage credit See [How to access and manage billing details](/products/pro/settings/billing/how-to-access-and-manage-my-billing-details/) for step-by-step instructions, or [how seat billing works](/products/pro/settings/billing/how-seat-billing-works/) for the model itself. ### Seat model Tallyfy bills per seat. You commit to a number of full and light seats and pre-pay for your term. Your active members draw from that committed pool, and seats free up when members are deactivated. You can buy more seats anytime, with the cost pro-rated for the rest of your term, and at renewal your plan trues down to the lowest seat count you held. For the full picture, see [how seat billing works](/products/pro/settings/billing/how-seat-billing-works/). :::note[Annual plans] Annual plans are a 12-month commitment. Cancelling an annual plan doesn't entitle you to a refund of the remaining months. The plan runs for the full term, and you keep access until it ends. ::: ### Paying by credit pre-payment Accounts payable teams can pre-fund a credit balance instead of paying per charge. The balance is drawn down as seats and add-ons are billed. It's a funding method for invoiced customers and sits alongside the seat model. See the [Terms for Credit Purchase](https://tallyfy.com/legal/terms-for-credit-purchase/), and keep a valid card on file so service continues if a balance runs low. ### Billing notifications By default, you'll get billing emails instantly when changes happen (like adding a new member). Contact support to switch to daily billing notifications - one summary email instead of instant updates. ### What happens if my payment fails? It depends on how you pay. If you pay by card, a failed charge shows a banner asking you to update your card, and a single failure doesn't lock your account. If you're billed by invoice, an invoice that's about 30 days overdue puts your organization into read-only mode until it's paid, after which access returns automatically. For the full breakdown of banners, read-only mode, and how to restore access, see [what happens if my payment fails](/products/pro/settings/billing/what-happens-if-my-payment-fails/). ### 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 sets 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 in an eligible country * You must be on an annual plan To apply: :::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/)* ### Org settings - **[Organization branding](https://tallyfy.com/products/pro/settings/org-settings/how-can-i-personalize-my-tallyfy-branding-and-emails/)**: Tallyfy lets admins customize branding by uploading a logo, selecting brand colors, and adding global CSS for content styling. Full white-labeling isn't available due to security and compliance constraints tied to the tallyfy.com domain. ## Customizing Tallyfy with your organization's branding Admins can customize Tallyfy to match your company's visual identity - including your logo, brand colors, guest-facing interfaces, and custom CSS styling. ### Changing logo and colors :::tip[Logo upload requirements and troubleshooting] **File format**: JPG, JPEG, PNG, and GIF formats are supported. **Recommended size**: 200x50 pixels (or similar aspect ratio) **File size**: Maximum 10 MB **Troubleshooting**: If your logo shows as a spinning circle or won't upload: - Resize to recommended dimensions - Clear browser cache and try again - Try a different browser if issues persist ::: ![Tallyfy branding settings showing logo upload and color selection](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-customizing-branding.png) ![Tallyfy tasks view with custom brand colors applied](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. ::: You can add custom CSS rules to change how headings, lists, tables, and other elements appear in task descriptions, [templates](/products/pro/documenting/templates/), and [documents](/products/pro/documenting/documents/) across your Tallyfy account. For example, you could make all H2 headings use a specific brand color, or restyle tables to match your corporate design. ```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-weight: 400 !important; } h1, h2, h3 { margin-top: 1rem !important; margin-bottom: 1rem !important; } ``` ### Why complete white-labeling isn't available Tallyfy offers extensive branding options, but complete white-labeling (hiding all Tallyfy references) isn't feasible. Here's why. #### Technical limitations * **Security compliance**: [HSTS](/products/pro/compliance/hsts-compliance/) and [BIMI](/products/pro/compliance/bimi-compliance/) compliance are tied to the `tallyfy.com` domain. These security protocols can't function on custom domains. * **JavaScript library restrictions**: Several JavaScript libraries and security components can only run on the `tallyfy.com` domain for security and licensing reasons. * **Clickjacking protection**: Security controls prevent logins and signups outside the Tallyfy domain, protecting users from phishing attacks. #### Operational realities * **Documentation**: This user manual is hosted on `tallyfy.com`. Your users will need access to help docs, revealing Tallyfy as the platform. * **Support**: Unless you handle 100% of support internally, users will contact [Tallyfy support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/) - immediately revealing the vendor. * **Compliance**: SOC 2 Type 2 certifications are assigned to Tallyfy, Inc. You can't hide Tallyfy's existence in the compliance lifecycle. * **Billing**: While [Tallyfy partners](/products/pro/miscellaneous/how-can-i-become-a-tallyfy-partner/) can use "unbilled domains" to exclude their consulting domain from client billing, invoices still show "Tallyfy" as the service provider. #### What you can customize * **Visual branding**: Your logo, colors, and custom CSS across the app * **Email sending**: Configure [custom SMTP](/products/pro/integrations/email/how-to-set-up-custom-smtp-in-tallyfy/) so emails come from your own server * **Partner options**: The [Ambassador program](https://tallyfy.com/partners/) provides extra branding options for qualified partners ### Setting up custom email sending (SMTP) You can configure Tallyfy to send all emails through your company's email server instead of Tallyfy's default. This keeps your brand consistent across all 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/)**: To remove a member from a Tallyfy organization, admins must first deactivate them. Tallyfy prompts you to reassign pending tasks and prevents deletion of the last admin. ## Removing a member from your organization Admins can remove a [member](/products/pro/documenting/members/) from a Tallyfy organization through a two-step process - disable first, then delete. This prevents accidental data loss and gives you a chance to reassign their work. ### Deletion constraints #### Administrator protection - **Default Administrator** - If the member being removed is the default admin and another member exists, Tallyfy auto-transfers the default admin role. If no other member exists, you'll see: "Cannot modify the default administrator. Please assign another member as default administrator first." - **Last Administrator** - You can't remove the last admin. Promote another member to admin first. - **Bot accounts** - System accounts like "Tallyfy Bot" can't be removed. #### Common blockers If you can't 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 more help, see the [troubleshooting guide](/products/pro/settings/org-settings/troubleshooting-member-deletion/). ### Task reassignment during removal When you deactivate a member, Tallyfy prompts you to reassign their pending [tasks](/products/pro/tracking-and-tasks/tasks/) and [template steps](/products/pro/documenting/templates/) to another active member. ![Task reassignment dialog when removing a member](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-conflict-resolution-example.png) Once you've reassigned everything, Tallyfy confirms the member's been removed. ### Checking who removed a member Find the deactivated member in the **Members** list (use filters if needed) and check the **Activity** section near the bottom of their profile. It shows who deactivated them. - **[Update organization details](https://tallyfy.com/products/pro/settings/org-settings/how-can-i-update-my-organization-details/)**: Tallyfy administrators can update their organization's name, address, country, and other details. Go to Settings, then Org Details under My Organization, and click Save. ## Updating organization details Only Tallyfy administrators can change your organization's name, address, city, state, country, zip code and other details. Here's how. :::note[Organization name limitations] **Can't change your organization name?** During initial setup, the organization name field may be locked in the UI. Contact [Tallyfy support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/) if you need help changing it. ::: - **[Customize work week](https://tallyfy.com/products/pro/settings/org-settings/how-to-adjust-task-deadlines-to-work-week/)**: Tallyfy lets administrators configure work week patterns and business hours so task deadlines automatically shift to the next working period when they fall on non-working days. It doesn't yet account for national holidays or individual vacation time. ## Adjusting task deadlines to match your work week Tallyfy can automatically shift [deadlines](/products/pro/tracking-and-tasks/tasks/) so they never land on non-working days or outside business hours. An Administrator configures this once, and it applies organization-wide. ### Configuring working days and hours :::note[How deadlines adjust] If a calculated deadline falls on a non-working day or outside your set working hours, Tallyfy **always pushes the deadline forward** to the start of the next working period. It won't move deadlines backward. Example: A deadline calculated for Saturday moves to Monday morning (assuming Monday is a workday). ::: ### What's not supported yet Tallyfy's deadline calculations use the work week pattern you configure - but they don't account for: - **Country-specific holidays** (e.g., Labor Day, Boxing Day) - **Organization-specific holidays** (e.g., company closure days, annual shutdown) - **Person-specific unavailability** (e.g., vacation days, sick leave) :::tip[Public holiday data coming soon] Tallyfy maintains a dataset of national holidays for 200+ countries at [tallyfy.com/national-holidays](https://tallyfy.com/national-holidays/). A future release will integrate this data into deadline calculations, so deadlines automatically skip national holidays in your country. ::: :::note[Need these features now?] If your organization needs holiday-aware or vacation-aware deadline calculations, [contact our support team](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/). Your feedback helps prioritize our roadmap. ::: - **[Auto-launch templates](https://tallyfy.com/products/pro/settings/org-settings/how-to-auto-launch-templates-for-new-members/)**: Tallyfy can automatically launch an onboarding template for every new member who joins your organization. Everyone gets the same structured experience without manual effort. ## Auto-launch a template for new members You can automatically launch a [template](/products/pro/documenting/templates/) whenever a [new member](/products/pro/documenting/members/) joins your organization. Every new member gets the same onboarding experience - no manual work required. ### Before you start - You need Administrator access to your Tallyfy organization - Have an existing [template](/products/pro/documenting/templates/) ready for onboarding - The template must be a procedure type (not a document) with at least one step, and can't have required kick-off form fields ### Setting up auto-launch ### How it works When a new member accepts their invitation and verifies their email: 1. The selected [template](/products/pro/documenting/templates/) launches as a [process](/products/pro/tracking-and-tasks/processes/) assigned to that member 2. They get email notifications about their [assigned tasks](/products/pro/tracking-and-tasks/tasks/) 3. The process shows up in their [Tasks view](/products/pro/tracking-and-tasks/tasks-view/) right away 4. Standard tracking and completion rules apply ### Why use auto-launch - **Consistent onboarding** - every new member gets the same process - **Self-paced training** - members complete tasks on their own schedule - **No manual work** - you don't have to launch onboarding processes one by one - **Faster adoption** - members start using Tallyfy immediately - **Avoids the [forgetting curve](/products/pro/tutorials/why-documentation-training-fails-forgetting-curve/)** - structured tasks beat one-time training sessions - **Trackable progress** - monitor who's completed onboarding and who hasn't ### What to include in your onboarding template - Welcome message and company info - Tallyfy tutorial steps with links to help articles - Introductions to key team members - Required training materials or [compliance](/products/pro/compliance/) documents - A feedback step at the end ### Good to know - The template launches as soon as the new member activates their account - Only one auto-launch template can be active at a time - Administrators can track completion progress in the [Tracker view](/products/pro/tracking-and-tasks/tracker-view/) - Pair this with [welcome snippets](/products/pro/documenting/templates/snippets/) for a complete onboarding experience - **[Customize your organization](https://tallyfy.com/products/pro/settings/org-settings/organization-customization-settings/)**: Tallyfy's organization customization settings let admins control member permissions and invitations along with domain-based auto-join and guest detection and HTML editing and template visibility and automatic task completion and process archiving and default deadlines and onboarding template launches and working hours and email digest schedules and webhook date formats all from one central page. ## Customizing organization settings Go to **Settings > Organization > Customization** to control how Tallyfy works for everyone in your org. You'll find all the options below on a single page. ### Member permissions * **Allow non-Admins to invite members?** - If **Yes**, Standard members can invite others (limited to Standard or Light roles). If **No**, only Administrators can send invites. It's a good idea to restrict this if you want tighter control over who joins. * **Allow non-Admins to create/manage groups?** - If **Yes**, Standard members can create and manage [groups](/products/pro/documenting/groups/). If **No**, only Administrators handle groups. ### Organization domains Managed under **Settings > Organization > Domains**. #### Domain configuration Add your company's email domains (e.g., `yourcompany.com`) under **Settings > Organization > Domains**. These domains serve two purposes: * **Distinguish members vs. guests** - Tallyfy uses this list to identify internal members (email matches a listed domain) vs. external guests. * **Auto Join** - If **ON**, anyone signing up with an email matching your domains automatically joins your org. This prevents employees from accidentally creating separate accounts. #### Adding domains 1. Go to **Settings > Organization > Domains**. 2. Follow the on-screen instructions to add, edit, or remove domains. ### Content creation * **Enable HTML authoring?** - If **Yes**, users can edit HTML directly in text editors for advanced formatting. If **No**, they use the standard visual editor. * **Set new templates viewable by creator/Admin only?** - If **Yes**, newly created [templates](/products/pro/documenting/templates/) are visible only to the creator and Administrators until shared. ### Task management * **Auto-complete overdue tasks?** - If **Yes**, Tallyfy automatically marks [tasks](/products/pro/tracking-and-tasks/tasks/) complete when they exceed their deadline by a set number of months (configurable from 2 to 24 months). This won't affect tasks that are still within their deadline window. * **Auto-archive completed processes?** - If **Yes**, Tallyfy archives [processes](/products/pro/tracking-and-tasks/processes/) after a set period (1-90 days or weeks) once all tasks are done. * **Default deadline for tasks** - Set a fallback deadline (e.g., 3 days) that applies to new tasks or template steps when no specific deadline is chosen. Supports minutes, hours, days, weeks, or months. ### Onboarding settings * **Launch template for new members** - Pick a [template](/products/pro/documenting/templates/) to auto-launch for every new [member](/products/pro/documenting/members/) who joins. 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 org's standard work days (e.g., Mon-Fri). * **Default working hours** - Set start and end times for the workday. Deadlines 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)** - Set the default days *new* members and guests receive summary emails. They're free to change their own schedule later. * **Send reminders for tasks whose start date is in the future?** - If **Yes** (the default), daily digest emails include every open task with a deadline, even ones that have not reached their start date yet. If **No**, member and guest digest emails leave out tasks whose start date is still in the future. Each task starts appearing once its start date arrives, and tasks with no start date always appear. Tasks that were never given an explicit start date are currently treated as starting shortly before their deadline, so turning this off is most useful when your templates and one-off tasks set real start dates. ### Webhook date formatting * **Format of webhook date field values** - Choose the date format for data sent via [webhooks](/products/pro/integrations/webhooks/). ### Saving changes Click **Save Changes** at the bottom of the page after making changes. - **[System log](https://tallyfy.com/products/pro/settings/org-settings/system-log/)**: Tallyfy's System Log gives administrators a single place to see webhook failures, email delivery events, billing changes, security events, automatic process actions, and AI usage for their organization. Three tabs cover system events, email events, and AI usage. Data is retained for 90 days and can be filtered, searched, and exported as CSV. ## What the system log shows The System Log is an admin-only view of every customer-relevant event captured for your Tallyfy organization. It answers questions like: * "Did our webhook to the CRM fail yesterday?" * "Did the welcome email to alice@example.com get delivered or did it bounce?" * "How much did our team spend on the AI assistant last month?" * "Who tried to log in with a wrong password to my org last week?" Three things are tracked: server-side system events, email delivery events, and AI usage events. The log is read-only. You can't edit or delete entries from it. The rest of this page covers how to open the log, what each of the three tabs shows, how to find and export events, and a few things worth knowing about retention and privacy. ## Open the system log Open the left sidebar and click **System Logs**. The page opens to the **System** tab by default. Use the tabs at the top to switch between System, Email, and AI Usage views. If you don't see **System Logs** in the sidebar, your role is not Administrator. Ask an Administrator to elevate your role, or to share an export with you. ## What each tab shows ### System tab Captures events that happen inside Tallyfy's backend on behalf of your organization. Five categories: | Category | What it captures | |----------|------------------| | Webhook | Outgoing webhook calls Tallyfy makes to your endpoints (success and failure, with HTTP status). | | Email | Server-side send attempts (separate from the per-recipient delivery events on the Email tab). | | Billing | Recurly payment outcomes and subscription state changes. | | Security | Failed login attempts, password resets, role changes, email-address changes, and "made public" actions on blueprints and kickoff forms. | | Process | Auto-archive and auto-complete actions performed by Tallyfy's bot user against your processes and tasks. | #### Full list of system events | Event | Category | Meaning | |-------|----------|---------| | `webhook_sent` | Webhook | A webhook was sent successfully (HTTP 2xx). | | `webhook_failed` | Webhook | A webhook failed. The full URL and HTTP status are visible in the row. | | `email_sent` | Email | Server attempted to send an email (per-recipient delivery is on the Email tab). | | `email_send_failed` | Email | Server-side send attempt failed before reaching the email provider. | | `smtp_send_failed` | Email | The configured SMTP transport rejected the message. | | `billing_payment_succeeded` | Billing | Recurly confirmed a successful charge. | | `billing_payment_failed` | Billing | Recurly rejected a charge. The reason from Recurly is visible in the row. | | `billing_subscription_created` | Billing | A new subscription was created for the org. | | `billing_subscription_updated` | Billing | The subscription plan or quantity changed. | | `billing_subscription_expired` | Billing | The subscription lapsed (typically after repeated payment failures). | | `login_failed` | Security | A login attempt for an email belonging to your org failed (wrong password, a failed multi-factor (MFA) check, and so on). | | `password_reset_initiated` | Security | A password-reset email was requested for an account in your org. | | `password_reset_completed` | Security | A user in your org successfully completed a password reset. | | `role_changed` | Security | An Administrator changed another member's role. | | `email_address_changed` | Security | A member changed their login email. | | `blueprint_made_public` | Security | An Administrator made a blueprint public (anyone with the link can view). | | `kickoff_form_made_public` | Security | An Administrator published a kickoff form publicly. | | `process_auto_archived` | Process | Tallyfy's bot user auto-archived a completed process per your archive policy. | | `task_auto_completed` | Process | Tallyfy's bot user auto-completed a task per your auto-complete rules. | ### Email tab Per-recipient delivery and engagement events from Mailgun, the email provider Tallyfy uses. This tab is the most useful answer to "did this customer actually receive the email?". | Event | Meaning | |-------|---------| | `email_sent` | Tallyfy handed the message to Mailgun for delivery. | | `email_delivered` | Mailgun confirmed the receiving server accepted the message. | | `email_failed` | A delivery attempt failed (transient or permanent). | | `email_bounced` | The receiving server permanently rejected the message (invalid address, mailbox full, blocked, etc.). | | `email_unsubscribed` | The recipient clicked the unsubscribe link. | | `email_complained` | The recipient marked the message as spam in their mail client. | | `email_send_failed` | Tallyfy couldn't hand the message to Mailgun (rare). | | `smtp_send_failed` | The custom SMTP transport (if configured) rejected the message. | ### AI usage tab Captures every interaction the AI assistant or MCP tools (outside AI apps that connect to Tallyfy) have on behalf of users in your org. Events vary by interaction type (a chat message, an MCP tool call, an embedding request) but each row carries the same fields: * **User** that made the request * **Model** used (for example, Opus or Sonnet) * **Prompt tokens / completion tokens / total tokens** * **Cost (USD)** for the request * **Latency (ms)** * **Success / error** with the error message if it failed Use this tab to track AI spend by team member, watch latency trends, and find failing requests when a user reports the AI behaving oddly. ## Find and export events ### Filter and search Every tab has the same filter controls along the top. The filter panel collapses on narrow screens. * **Date range** picker. Maximum 90 days. The picker won't let you go further back. * **Category** (System tab only) and **Event type** multi-select chips. * **Severity** (System tab only): error, warning, info. * **Global search** box. Free-text search across event names and error messages. It's case-insensitive (a search for `connection refused` matches `Connection refused`). * **Advanced filters** (collapsible): per-column "contains" search for event name, message, recipient, and subject. * **Actor** picker for the user who triggered the event. There's a "Bot user" preset that selects your org's automation bot, so you can answer "what did the bot do this week?" in one click. * **Sort by** column with ascending / descending toggle. * **Page size**: 25, 50, 100, or 200 rows per page. ### Export to CSV Click **Export CSV** in the toolbar. The export uses your current filters and streams rows to a downloaded file. There's no row cap. A 90-day window for a busy org typically exports in a few seconds. The CSV includes the same columns visible in the table plus the full message body. Use it for compliance archives or to share specific failures with engineering. ## Good to know ### Login and password events from before sign-in Failed-login and password-reset events happen before the user is signed in, so Tallyfy can't tag them with an org ID at capture time. The System Log resolves them to your org by matching the entered email address against your member list. So you'll see: * Failed login attempts where the email belongs to a member of your org. This helps you spot credential-stuffing, where attackers try many stolen passwords against your accounts. * Password resets initiated for emails that belong to your org, plus the matching `password_reset_completed` event when the user finishes. You won't see: * Failed logins for email addresses that aren't yet members of any org. Tallyfy can't safely assign these to your org. * SSO denial events that don't capture the attempted email. * Invitation events for an invitee who's not yet a Tallyfy user. These are tracked separately and may be added in a later release. A small **Pre-auth** badge appears next to events resolved this way, so you can tell them apart from events captured directly with your org ID. If you want to hide pre-auth events from a search, toggle off **Include pre-authentication events** in the filter panel. ### Who viewed the log Every time someone opens or exports the System Log, Tallyfy records a `system_log_viewed` event. It shows up in the System tab itself, with the user, timestamp, log type, and the filters that were applied. This is on purpose: if your org needs to know who's been auditing, you can answer that question from inside the same UI. This record of log views is visible to all Administrators and exports normally with CSV. ### How long events are kept System Log data is retained for 90 days. Events older than 90 days are removed and cannot be recovered. If you need a longer history, export the CSV monthly and archive it in your own storage. The 90-day cap is a hard limit. The date-range picker won't let you go past it. If you need an older event for an active investigation, contact support quickly: we may still have it in our internal logging stack, but we can't promise anything past 90 days. ### What's not logged For privacy and security, the following are deliberately excluded: * Raw API request and response bodies. Use Tallyfy's API audit trail (separate feature) if you need request-level inspection. * Internal monitoring events (uptime probes, capacity forecasts, queue health checks). These would be noise. * API keys, OAuth tokens, passwords, and session cookies. These are stripped before any event is written. We never log secrets. Webhook URLs are returned in full because customers want to debug their own integrations. If you put a secret in a webhook URL query string, that secret will appear in the log. Use webhook signing headers instead of URL parameters for secrets. ## Common questions **Why don't I see events from before yesterday?** Check the date-range picker. It defaults to the last 24 hours. Expand it to 90 days for the full window. **The Email tab is empty for an email I know we sent.** Two possibilities. Mailgun events arrive a few seconds after the send, so very recent emails may not have a delivery event yet (the `email_sent` event from the System tab will show, but `email_delivered` is in the Email tab and lags slightly). Or, the message was sent through your own SMTP transport, which doesn't report delivery back to Tallyfy. **Can I see what changed in a `role_changed` event?** Yes. Click the row to expand it. The "before" and "after" role values are in the detail panel, along with the user who made the change. **Can I get realtime updates without refreshing?** The page polls when you switch back to the tab, and there's a manual **Refresh** button in the toolbar. Realtime push updates are tracked as a separate feature request. - **[Member deletion](https://tallyfy.com/products/pro/settings/org-settings/troubleshooting-member-deletion/)**: To delete a member in Tallyfy, you must disable them first. This guide covers common blockers like default admin restrictions, bot user limits, task reassignment, and data retention. ## Troubleshooting member deletion Can't delete a member from your Tallyfy organization? You must disable a member before you can permanently delete them. Here's how to fix common blockers. ### Quick diagnosis 1. **Check member status** - Active, Disabled, or Invited? 2. **Check admin role** - Default Admin or Administrator? 3. **Count admins** - How many active admins in the organization? 4. **Note the exact error** - What message appears? ### Common error messages #### "Please disable the user before deletion." Tallyfy requires a two-step process - disable first, then delete: 1. Go to **Settings** > **Organization** > **Members** 2. Click the member's name 3. Click **Deactivate Member** 4. Reassign their tasks when prompted 5. Then permanently delete them #### "Cannot modify the default administrator." The full error reads: *"Cannot modify the default administrator. Please assign another member as default administrator first."* To fix this: 1. Click a different administrator's profile 2. Select **Make Default Administrator** 3. Go back to the original member 4. Proceed with deactivation No other admins? Promote a Standard member to Administrator first. #### "Bot users cannot be disabled." Bot accounts (like Tallyfy Bot) can't be removed or disabled. They don't count toward billing - they handle automated comments and system tasks. When removing a member through the `DELETE /organizations/{org}/users/{user_id}` endpoint, you'll see *"You can't remove a bot user from this organization!"* instead. #### No other admin available If you try to disable the only administrator, you'll get the "Cannot modify the default administrator" error. Promote any Standard member to Administrator first, then remove the original admin. ### Special scenarios #### Member shows as removed but still has access 1. Clear browser cache and cookies 2. Verify status shows "Deactivated" 3. Check for active API tokens - revoke them manually 4. If it's still happening after 30 minutes, contact support #### Can't find a deactivated member Tallyfy hides deactivated members by default: 1. Go to the **Members** list 2. Filter by **Show: All** or **Show: Deactivated** 3. Search by name or email #### Bulk member removal For multiple deletions via API: - Always disable before deleting (two-step process for each) - Space out requests to avoid rate limits - Process in reasonable batches ### System behavior details #### Email and name changes When permanently deleted, Tallyfy: - Appends "(Deleted)" directly to the last name (no space) - e.g. `Smith` becomes `Smith(Deleted)` - Changes email to `{email}.deleted.{user_id}` - e.g. `john@company.com` becomes `john@company.com.deleted.12345` This prevents conflicts if you re-invite that person later. #### What happens to member data **Removed immediately**: - Login access - Active sessions **Kept for compliance**: - Task completion history (name shows with "(Deleted)") - Process participation records - Comments and attachments - Audit trail entries #### Task reassignment Tasks never fall to "Tallyfy Bot". The bot can't be assigned tasks at all (see [member statuses](/products/pro/settings/org-settings/understanding-member-statuses/)). When a deactivation skips reassignment, which is what an API deletion does if you don't pass a reassignment target, those tasks keep the deactivated member as their owner. Nothing moves on its own, so reassign them yourself when you're ready. ### API deletion **Two-step sequence**: ``` 1. DELETE /organizations/{org}/users/{user_id}/disable 2. Wait for 200 response 3. DELETE /organizations/{org}/users/{user_id}/delete ``` **Single-step with reassignment**: ``` DELETE /organizations/{org}/users/{user_id}?with_reassignment=true&to={new_user_id} ``` The single-step endpoint handles deactivation and removal together, and reassigns tasks to the specified member. ### Edge cases #### Organization with a single member - You can't delete the last member - Contact support for organization closure #### Circular admin dependencies If Admin A backs up Admin B and vice versa, add a third admin temporarily to break the cycle. ### Recovery Accidentally deleted someone? Contact support immediately with: - Organization name - Member email - Deletion date Recent deletions may be restorable. For older ones, send a new invitation. ### When to contact support - Error messages don't match those listed here - Server errors (500-series) appear during deletion - Deletion seems stuck for over an hour **Provide**: organization name, member email, exact error message, screenshot ### Prevention tips - Keep at least 2 administrators at all times - Document who the default administrator is - Use consistent offboarding procedures - **[Member statuses](https://tallyfy.com/products/pro/settings/org-settings/understanding-member-statuses/)**: Every Tallyfy organization member has one of four statuses: Active, Invited, Deactivated, or Bot/Unbilled. Each status controls platform access and whether the member counts toward billing. Every person in your Tallyfy organization has a status you can check at **Settings > Organization > Members**. The status controls what they can do and whether they count toward your billing. There are four: Active, Invited, Deactivated, and Bot / Unbilled. ## The four statuses at a glance | Status | Meaning | Counts toward billing? | |---|---|---| | **Active** | Can log in and use Tallyfy based on their role | Yes | | **Invited** | Invitation sent, but not yet accepted | No | | **Deactivated** | Removed from the organization - can't log in | No | | **Bot / Unbilled** | Special account for integrations or partners | No | ## What each status means ### Active An Active [member](/products/pro/documenting/members/) has joined and can use Tallyfy based on their role (Admin, Standard, or Light). These members count toward your account limits. ### Invited "Invited" means you've sent an invitation, but the person hasn't clicked the email link and set up their password yet. They can't use Tallyfy and don't count toward billing. Once they accept, their status automatically changes to **Active**. ### Deactivated An Administrator has removed this member. They can't log in or access anything in Tallyfy. When you deactivate someone, Tallyfy lets 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 don't count toward billing. ### Bot / Unbilled This status covers a few different cases: - **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 show as "Unbilled". - **Tallyfy Bot** - Every organization has a system user called "Tallyfy Bot". It posts automated comments (for example, when a rule triggers a task) and handles system actions that can't be attributed to a specific person. The bot can't be removed, edited, or assigned tasks. These accounts can access Tallyfy but don't count toward the organization's billed member total. For partner/consultant accounts specifically, this only applies in client organizations that have added the partner's domain to their exclusion list - not in the partner's own Tallyfy organization. ## Managing statuses Administrators manage all member statuses at **Settings > Organization > Members**. From there you can: 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. View everyone's current status at a glance. ### Rules for deactivating and deleting These protections apply when deactivating or deleting members: - **Default Administrator** - If you deactivate a default admin who's also the only admin, you'll get an error. Promote another member to Admin first. If other admins exist, Tallyfy auto-transfers the default admin role. - **Last Administrator** - The final admin in an organization can't be deactivated. Promote another member first. - **Two-step deletion** - Members must be deactivated before you can permanently delete them. - **Task reassignment** - You can reassign active tasks and template assignments to another member during deactivation. Hit errors during deactivation? See the [troubleshooting guide](/products/pro/settings/org-settings/troubleshooting-member-deletion/). ### Personal settings - **[Delete your account](https://tallyfy.com/products/pro/settings/personal-settings/how-can-i-cancel-and-delete-my-tallyfy-account/)**: Only an Administrator can permanently delete a Tallyfy organization through Settings > Billing by submitting an official closure form. All data is irreversibly removed after a 90-day backup retention window. ## Permanently deleting your Tallyfy account Only an Administrator can delete a Tallyfy organization. This action is **irreversible** - all data is permanently removed. :::warning[Deletion is permanent and irreversible!] * Once deleted, all organizational data, processes, templates, and user information are **permanently removed**. Nothing can be restored. * You **must** use the official closure form. Informal requests like support emails won't be processed due to privacy and security policies. ::: ### Data retention after deletion - **30-day export window** - export any data you need 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 form, a Tallyfy team member will review your request and confirm when deletion is complete. All billing stops permanently at that point. :::note[Active annual subscriptions] Deleting your account doesn't entitle you to a refund of any remaining time on an annual subscription. If you have an active annual plan, consider canceling first and using the remainder of your term before requesting deletion. ::: - **[Change my email address](https://tallyfy.com/products/pro/settings/personal-settings/how-can-i-change-my-email-address-in-tallyfy/)**: Tallyfy lets email/password users update their login email through Settings > My Account > My Profile with password confirmation. SSO and social login users must instead invite their new email as a member and deactivate the old account. ## Updating your login email Change your email by going to **Settings** > **My Account** > **My Profile**, editing the **Email** field, and saving. You'll need to confirm with your current password. :::note[Special process for SSO and social signup users] If you signed up via [Single Sign-On (SSO)](/products/pro/integrations/authentication/) or social login (Google, Microsoft), you can't change your email directly. These accounts don't have passwords in Tallyfy, so you'll need to follow the [member transition process](#sso-and-social-login-users) below. ::: ### Prerequisites * You're logged in to Tallyfy with your current email * You have access to *both* your current and new email inboxes * You signed up with a regular email and password (not SSO or social login) ### Steps to update your email ### Using your new email :::note[Limits on email changes] Free plans are limited to 3 email changes per day. Paid plans don't have this restriction. ::: ### Troubleshooting * Double-check for typos in the new email address * Make sure you can receive emails at the new address (check spam folders) * If you can't log in after the change, [contact Tallyfy Support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/) with both your old and new email addresses ## SSO and social login users If you use [SSO](/products/pro/integrations/authentication/) or social login (Google, Microsoft), you can't edit your email directly. The email change process requires password verification, and SSO/social accounts don't have passwords stored in Tallyfy. Instead, use a member transition. ### Changing email for SSO/social login accounts - **[Reset your password](https://tallyfy.com/products/pro/settings/personal-settings/how-can-i-change-or-reset-my-tallyfy-password/)**: Change your Tallyfy password from the Security tab in profile settings, or reset a forgotten password via email link. If you hit authentication loops during reset, force logout and clear all Tallyfy cookies before trying again. ## Change or reset your Tallyfy password You can update your password two ways - change it while logged in, or reset it if you've forgotten it. ### Change password while logged in ### Reset a forgotten password ### Password requirements Your Tallyfy password must: - Be at least 6 characters long - Include at least one uppercase letter (A-Z) - Include at least one lowercase letter (a-z) - Include at least one number (0-9) Maximum length is 127 characters. ### Troubleshooting password reset - Double-check you're entering the correct email for your Tallyfy account - Reset links expire after 60 minutes - request a new one if yours has expired - If you don't receive the email (after checking spam), [contact Tallyfy Support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/) with your name, company name, and the email address linked to your account ### Fixing authentication loops If password reset keeps redirecting you to create a new account or asking for credentials repeatedly, visit [https://account.tallyfy.com/logout](https://account.tallyfy.com/logout) to force a complete logout. Then follow these steps: :::tip[Why this happens] Authentication loops during password reset typically happen 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 ::: - **[Manage email notifications](https://tallyfy.com/products/pro/settings/personal-settings/how-can-i-manage-email-notifications-in-tallyfy/)**: Control which email notifications Tallyfy sends you for task assignments, comments, deadlines, and process completions. You can also set up digest emails at 6 AM on chosen days to summarize upcoming or overdue tasks. ## Managing email notifications You can control exactly which emails Tallyfy sends you - from task assignments to comment alerts to process completions. To change your settings: 1. Click your profile picture/name (top right) > **Settings**. 2. Go to **My Profile** > **Email Notifications** tab. Toggle each notification type ON or OFF. For example, if you don't want an email every time someone completes a task you assigned, turn that notification OFF. The available notification types include: - **Task assignments** - emails about tasks where you're assigned - **Other people's task updates** - when others complete or update tasks - **Comments** - comments on tasks where you're assigned - **@mentions** - when someone @mentions you in a comment - **Process completed** - when a process you're part of finishes - **Deadline changes** - when task deadlines are changed ![Tallyfy email notification settings screen](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 get immediate email notifications for those tasks. This prevents email spam when launching processes. **Why this happens**: - Tallyfy 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 right away **To make sure you get reminders**: - Turn on daily digest emails in your settings - Set deadlines on tasks - Other assignees will get immediate notifications as normal **Special case - Zapier-initiated processes**: If Zapier starts a process with you as the process starter, you won't get task notifications either. Workaround: have Zapier assign a different user as the process starter, or use webhooks for external notifications. ::: ### Digest emails (reminder settings) Tallyfy sends digest emails at 6 AM in your local timezone, summarizing tasks that are due soon or overdue. If your administrator turned off reminders for future-start tasks in [organization customization settings](/products/pro/settings/org-settings/organization-customization-settings/), tasks whose start date hasn't arrived yet won't appear in your digest. * **Choose your days**: Pick which days of the week you want to receive the digest. The default is Monday, Wednesday, and Friday. * **Turn it on or off**: You can toggle the daily digest preference on or off in your notification settings. * **Troubleshooting**: If someone says they aren't getting reminders, have them check their notification settings first. 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. - **[Update your profile picture](https://tallyfy.com/products/pro/settings/personal-settings/how-can-i-set-up-my-profile-photo-on-tallyfy/)**: Upload or change your Tallyfy profile picture from Settings > My Account > Profile. Select and crop a JPG, PNG, or GIF image (max 2 MB) that appears instantly across the platform. ## Uploading or changing your profile picture Your profile picture appears next to tasks you're assigned to and in system emails. It helps teammates recognize you at a glance. Here's how to add or change your photo: Your new photo appears across Tallyfy right away. You don't need to click **SAVE CHANGES** separately for the photo. - **[Switch between organizations](https://tallyfy.com/products/pro/settings/personal-settings/how-can-i-switch-between-organizations-in-tallyfy/)**: Tallyfy lets users linked to multiple organizations switch between them instantly from their profile menu without logging out or managing separate credentials. ## Switching between organizations If your Tallyfy login email is tied to more than one organization (e.g., your company and a client's account), you can switch between them without logging out. The **Switch Organization** option only appears when you belong to two or more organizations. One login handles all your organizations - you don't need separate credentials. - **[Personalization settings](https://tallyfy.com/products/pro/settings/personal-settings/personalization-settings/)**: Personalize your Tallyfy experience through Settings > My Account. Adjust display preferences like language, time zone, and date format, or update profile details including name, email, photo, and password. ## Managing personal and profile settings Your personal Tallyfy settings live under **Settings** > **My Account**. Two tabs are available here. ### Personalization settings Control how Tallyfy displays information for you: * **UI Language** - pick the display language for menus and buttons (this won't translate task or template content) * **Time zone** - set your local time zone so deadlines and timestamps show correctly * **Date format** - choose your preferred format (e.g., MM/DD/YYYY or DD/MM/YYYY) * **Date display** - toggle between **Relative** dates (e.g., "Tomorrow", "In 2 days") and **Hard Dates** (e.g., "2023-10-27") * **Sounds** - turn task completion sounds on or off ![Tallyfy personalization settings screen](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-personal-settings-personalization.png) ### Profile settings Update your personal information here: ![Tallyfy profile settings screen](https://screenshots.tallyfy.com/tallyfy%2Fpro%2Fdesktop-light-personal-settings-profile.png) * **Profile Picture** - upload or change your photo * **Name** - edit your first and last name * **Email** - [change your login email](/products/pro/settings/personal-settings/how-can-i-change-my-email-address-in-tallyfy/) * **Job Title** - set your current job title * **Phone Number** - add or update your phone number * **Country** - select your country * **Team** - a text field for your team's name (doesn't link to Tallyfy groups) * **Password** - [change your password](/products/pro/settings/personal-settings/how-can-i-change-or-reset-my-tallyfy-password/) (you'll need your current password) Click **Save Changes** after updating any profile field. ### Billing - **[Billing add-ons and usage credit](https://tallyfy.com/products/pro/settings/billing/billing-add-ons-and-usage-credit/)**: Two kinds of add-ons sit on top of your seats. Analytics is priced per seat per year on every committed seat and scales automatically. AI tokens and per-task credit are pre-paid balances you buy upfront and draw down daily as you use them. ## Two kinds of add-ons Tallyfy has two kinds of add-ons that sit on top of your seats. **Analytics** is a yearly add-on priced per seat, charged on every full and light seat. **Usage credit** (AI tokens and per-task credit) is a pre-paid balance you buy upfront and draw down as you use it. You manage both from **Settings** > **Billing**. ## Analytics add-on Analytics costs $20 per seat, per year, charged on every committed seat (full and light). Turn it on with a single toggle, and Tallyfy shows the computed annual amount (your total seats times $20) before you confirm. It scales automatically: add seats mid-term and your Analytics charge grows to match, with no separate step. For multi-entity accounts, Analytics appears as a single line across all your linked workspaces on your invoice. ## Pre-paid usage credit AI tokens and per-task credit work as pre-paid balances. You buy an amount upfront, and Tallyfy draws it down as you use the feature. You're never billed after the fact for usage. Your balance updates once a day, so "drawn down daily" is exactly what it sounds like. Two things to watch for: * **Low balance** - when your credit runs low, you'll see a banner: "Your credit is running low. Top up to avoid interruption." * **Out of AI token credit** - when your AI token balance reaches zero, AI features pause with "You're out of credit. Top up to continue." This is a hard stop, not a warning. AI stays paused until you top up. * **Out of per-task credit** - your work is never blocked. Tasks keep completing normally and Tallyfy keeps recording the usage, so the balance goes negative and shows as a shortfall. You'll be asked to settle it. Nobody gets locked out of their own processes over a billing balance. :::note[Usage credit pricing] Pricing for AI tokens and per-task credit is being finalized. [Contact Tallyfy Support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/) for current rates. ::: ## Top up your credit ## How you pay for add-ons How you pay depends on your billing type: * **Card (automatic) accounts** pay for add-ons and credit top-ups instantly by card. * **Invoiced and multi-entity accounts** get add-ons and credit on their Xero invoice, paid by ACH or wire transfer. [Contact Tallyfy Support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/) to arrange these. - **[How seat billing works](https://tallyfy.com/products/pro/settings/billing/how-seat-billing-works/)**: Tallyfy bills per seat. You commit to a number of full and light seats, pre-pay for your term, and active members draw from that pool. Seats free up when members are deactivated, and your plan trues down at renewal. ## Seat billing in plain terms Tallyfy is billed per seat. A seat is a paid license for one person on your team. You commit to a number of seats, pre-pay for your term, and your active members draw from that pool. You can hold more seats than you're using, so new people can join without a delay. There are two seat types, plus free guests. ## Full seats and light seats The two paid seat types cover different kinds of work: * **Full seats** can create and edit templates, launch and assign work, and track, approve, and complete tasks. * **Light seats** are a lower-cost license for people who only complete the tasks assigned to them. Guests from outside your organization stay free and never use a seat. They only see the specific tasks you share with them. For what each seat type costs, see the [pricing page](https://tallyfy.com/pricing/). ## Your seat pool: committed and active Two numbers describe your seat pool, and Tallyfy tracks full seats and light seats separately: * **Committed seats** are the seats you've agreed to pay for over your current term. This is the number your plan bills. * **Active seats** are the seats in use right now. A seat is used when someone accepts an invite or signs in through single sign-on, and it returns to the pool when that member is deactivated. You can hold more committed seats than you've filled. The spare seats stay ready for new people. You can't lower your committed count below the number of active members, because those people are already working. ## When your bill changes Your committed seats stay fixed during your term unless you change them: * **Adding seats** happens anytime and is pro-rated for the time left in your term. See [how to buy more seats](/products/pro/settings/billing/how-to-buy-more-seats/). * **Reducing seats** takes effect at your next renewal, not mid-term. At renewal, your plan trues down to the lowest seat count you held during the period. This means you're never billed more than the seats you committed to, and a temporary dip in your team doesn't lower your committed total until the term turns over. ## Annual or monthly You can pay annually or monthly. Annual plans are a 12-month commitment and cost less per seat. Monthly plans commit for the current month. Free SSO and unlimited guests are included on every plan. See the [pricing page](https://tallyfy.com/pricing/) for current rates. :::note[AppSumo lifetime customers] Your AppSumo lifetime deal covers 3 full seats at no cost, forever, and nothing about that changes. Need more people? You can add seats anytime at standard pricing. Only the seats above your 3 free ones are billed. ::: - **[How the Seat Allocator works](https://tallyfy.com/products/pro/settings/billing/how-the-seat-allocator-works/)**: Multi-entity accounts run linked workspaces under one billing parent that shares a seat pool. The Seat Allocator lets a billing parent administrator distribute full and light seats across those workspaces from Settings then Billing. ## What the Seat Allocator is for Larger organizations can run several linked workspaces under one billing parent that shares a single seat pool. The **Seat Allocator** in **Settings** > **Billing** is where you split that shared pool of full and light seats across the linked workspaces. This page is for administrators of organizations that belong to a billing parent. If your account isn't set up this way, you won't see the Seat Allocator. To set up a multi-entity contract, [talk to our team](https://tallyfy.com/booking/). ## Who can view and who can change Every admin of a linked organization can open the Seat Allocator and see how seats are split. Only a designated **billing parent administrator** can change the allocations. If you're an admin without that role, you'll see a read-only view with a note: "You're viewing in read-only mode. Only billing parent administrators can change seat allocations." ## What you'll see The Seat Allocator has a header and three tabs: * **Header** - your shared pool of full and light seats, how many are allocated versus committed, your current term dates, and whether each entity is invoiced on its own or together. * **Allocations** - redistribute full and light seats across the linked organizations. * **History** - an audit trail of past allocation changes. * **Administrators** - the people who can change allocations. ## Allocate seats across your workspaces Billing parent administrators move seats between linked organizations within the committed pool: Two limits keep allocations valid. You can't allocate fewer seats to an organization than it currently has active, because those people are already working. And the total you allocate can't go above the committed pool. To grow the pool itself, [buy more seats](/products/pro/settings/billing/how-to-buy-more-seats/). ## Add an administrator or link a new organization Some changes are handled by Tallyfy Support to keep your billing accurate: * **Add an administrator** - on the Administrators tab, use **Add administrator**. This opens a pre-filled email to Tallyfy Support, who completes the change. A billing parent administrator can also revoke another administrator's access, but not the last remaining one. * **Request a new organization** - use **Request new organization** to open a pre-filled support email. Tallyfy Support links the new workspace to your billing parent. - **[Manage billing](https://tallyfy.com/products/pro/settings/billing/how-to-access-and-manage-my-billing-details/)**: Manage your Tallyfy subscription, seats, payment methods, and invoices from Settings > Billing. Only administrators can access billing, buy seats, apply coupons, or handle cancellations. ## Access your billing details Go to **Settings** > **Billing** to manage your subscription, seats, payment method, and invoices. Only administrators can access this section. ### View history and update payment From the **Billing** screen: * Click **View Billing History** for past invoices and a plan summary. See [understanding your billing history](/products/pro/settings/billing/understanding-your-billing-history/) for what the activity feed and invoice list show. * Click **Edit Payment Card** to update your credit or debit card. :::note[Keep a payment card on file] Keep a valid card saved even if you pre-pay by credit. This keeps your service running if a balance runs low. ::: ### Change the billing contact The user who created the organization is the default billing contact. To change it or add CC email addresses: ### Change your plan or buy seats If your trial hasn't been converted yet, you'll see a checkout to [subscribe to a paid plan](/products/pro/settings/billing/subscribing-to-a-paid-plan/). Once you're subscribed, the billing screen shows seat management. See [how to buy more seats](/products/pro/settings/billing/how-to-buy-more-seats/) for the full flow, including invoiced accounts. ### Add-ons and usage credit Analytics and pre-paid usage credit (AI tokens and per-task credit) appear in the billing section. See [billing add-ons and usage credit](/products/pro/settings/billing/billing-add-ons-and-usage-credit/) for what each one does and how to top up. ### Billing notification frequency Billing emails (invoices, payment confirmations, subscription updates) arrive instantly by default. To receive fewer emails: ### Use discount coupon codes :::note[Applying for 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. ::: ### Cancel your subscription Use the self-service cancellation form in Tallyfy when possible. :::caution[Annual plan cancellation] If you're on an annual plan, cancellation takes effect at the end of your 12-month term. Annual subscriptions are a full-year commitment. Tallyfy doesn't issue partial refunds or pro-rated credits for the remaining months. You keep full access until the term ends. ::: For monthly plans, cancellation takes effect at the end of the current month. :::tip[Emergency cancellation process] **If you can't access the cancellation form** (technical issues or location restrictions): 1. **Email support** at support@tallyfy.com from your registered email 2. **Include** your organization name, billing email, and reason for cancellation 3. **Request** written confirmation of cancellation and final billing status 4. Support typically processes urgent cancellations within 24 hours Cancellation takes effect at the end of your current billing period. You keep access until then. ::: ### What happens if I miss a payment? If you pay by card, a failed charge shows a banner asking you to update your card in **Settings > Billing > Edit Payment Card**. If you're billed by invoice, an invoice about 30 days overdue puts your organization into read-only mode until it's paid, after which access returns automatically. See [what happens if my payment fails](/products/pro/settings/billing/what-happens-if-my-payment-fails/) for the full details, 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 - **[How to buy more seats](https://tallyfy.com/products/pro/settings/billing/how-to-buy-more-seats/)**: Add full or light seats anytime from Settings then Billing. Choose a seat type, enter how many, and review the exact pro-rated amount for the rest of your term before you confirm. Seats activate once payment clears. ## Add seats to your plan You can add seats to your plan anytime from **Settings** > **Billing**. Choose whether you're adding full or light seats, enter how many, and review the exact pro-rated cost before you confirm. Only administrators can buy seats. ## How the pro-rated cost works When you add seats mid-term, you only pay for the time left in your current term, not a full term. The exact amount is calculated for you and shown before you confirm, so there are no surprises. Your card is charged when you confirm, and the new seats become available as soon as the payment clears. :::note[Light seat pricing] Light seat pricing is being finalized. If light seats show as not yet priced when you try to buy them, [contact Tallyfy Support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/) and we'll help. ::: ## If your card is declined There's no automatic retry. If a charge fails, nothing is added and nothing is charged. The dialog shows an **Update payment method** option so you can fix the card and try again. ## If you pay by invoice For accounts billed by invoice (manual or multi-entity billing), buying more seats adds them to your next invoice through Xero. The seats activate once that invoice is paid, rather than immediately. See [what happens if my payment fails](/products/pro/settings/billing/what-happens-if-my-payment-fails/) for how invoiced billing works. ## When your seat pool is full If you try to activate, invite, or promote someone and your seat pool is full, Tallyfy shows a dialog titled **No Seats Available**, reading "There are no full seats available in your pool." (or "light", depending on which pool ran out) and "Purchase additional seats to continue adding users." Choose **Buy More Seats** from that prompt and the waiting person is activated automatically once the purchase goes through. Choose **Cancel** and nothing changes. The person stays invited or disabled until a seat frees up or you buy more. Two things worth knowing about which pool the message names: * An invite holds a seat from the moment you send it, not from when the person accepts. So a pool can read as full because of invites nobody has accepted yet. Revoking a pending invite frees its seat immediately. * Members on a partner domain your account has marked as unbilled don't draw from either pool, so they never trigger this message. - **[Subscribe to a paid plan](https://tallyfy.com/products/pro/settings/billing/subscribing-to-a-paid-plan/)**: When your free trial is ready to become paid, open Settings then Billing to subscribe. Choose monthly or annual, confirm your seats, and pay by card. ACH or wire transfer is handled by our team. ## Turn your trial into a paid plan When your free trial is ready to become a paid plan, go to **Settings** > **Billing**. If you haven't subscribed yet, you'll see a short checkout. Only administrators can do this. Pick your billing term, confirm your seats, and pay by card to go live right away. ## Choose your seats Tallyfy is priced per seat, so the checkout starts you at the number of seats your current active members already use. You can't go below that count, because those people are already working in Tallyfy. You can add more seats now if you're growing, or leave it as is. You buy both seat types in the same checkout: * **Full seats** for people who build and run processes. * **Light seats** for people who only complete assigned tasks. For what each seat type costs, see the [pricing page](https://tallyfy.com/pricing/). To learn how the seat pool works after you subscribe, read [how seat billing works](/products/pro/settings/billing/how-seat-billing-works/). ## Pay by card The checkout takes a credit or debit card, processed securely by Recurly. Your card is charged when you subscribe. If it's declined, nothing changes and nothing is saved, so you can try another card. Two optional extras sit in the same checkout: * **Promo code** - enter one in the "Have a promo code?" field if you have it. * **Analytics add-on** - tick the box to add Analytics. See [billing add-ons and usage credit](/products/pro/settings/billing/billing-add-ons-and-usage-credit/) for what it includes. ## Prefer ACH or wire transfer? The self-serve checkout is card-only. If you'd rather pay by ACH, wire transfer, or against an invoice, our team sets that up for you. Use the **Contact support** link in the checkout, or [contact Tallyfy Support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/). Manual billing and multi-entity contracts are handled this way. After you subscribe, **Settings** > **Billing** switches to seat management, where you can [buy more seats](/products/pro/settings/billing/how-to-buy-more-seats/) and review your [billing history](/products/pro/settings/billing/understanding-your-billing-history/). - **[Understanding your billing history](https://tallyfy.com/products/pro/settings/billing/understanding-your-billing-history/)**: Settings then Billing shows your billing history. A plain-English activity feed lists billing events with timestamps, and a separate list holds your past invoices, which you can download as PDF from Recurly or Xero. ## Where to find your billing history Go to **Settings** > **Billing** to see your billing history. It has two parts: an **activity feed** of billing events written in plain language, and a **list of invoices** you can download. Only administrators can see this. ## The billing activity feed The activity feed is a running list of the billing events on your account. Each entry has a timestamp and a plain-English description, so you can see what changed and when. Typical entries include: * **Seat pool resized** - your committed seats went up or down. * **Purchase succeeded** - a seat purchase or add-on went through. * **Invoice paid in Xero** - an invoiced payment was received. * **Organization set read-only (payment overdue)** - an invoice passed its overdue limit. * **Organization reactivated** - access was restored after a payment. The feed shows the events that matter to you. Behind-the-scenes sync steps aren't listed, so the feed stays readable. ## Your invoices Below the activity feed is a list of your past invoices, each with a status such as paid, pending, overdue, or void. You can download any invoice as a PDF: If you pay by card, your invoices come from Recurly, our billing provider. If you're billed by invoice, they come from Xero. The download link is valid for a few minutes, so if it expires, just click again. To update the card itself, you'll see a secure Recurly screen. ## If your history looks empty or won't load A new account with no billing activity shows "No billing history yet" until your first purchase or invoice. If a filter hides every row, clear it to bring the list back. And if the page can't load your details, you'll see a short error with a **Retry** button. None of these mean anything is wrong with your account. - **[What happens if my payment fails](https://tallyfy.com/products/pro/settings/billing/what-happens-if-my-payment-fails/)**: What happens depends on how you pay. Card accounts see a banner asking you to update your card. Invoiced accounts that go about 30 days overdue are placed in read-only mode until the invoice is paid, then access returns automatically. ## It depends on how you pay What happens after a failed payment depends on your billing type. Card accounts get a banner asking them to update their card. Invoiced accounts that go about 30 days overdue are placed in read-only mode until the invoice is paid. Either way, your data is safe, and access comes back as soon as payment goes through. ## If you pay by card When a card charge fails, you'll see a banner in **Settings** > **Billing** that says your payment failed and asks you to update your payment method. Update the card on file and you're back to normal. A single failed charge doesn't lock your account on its own, so there's no rush beyond keeping a valid card on file. ## If you pay by invoice Invoiced accounts are billed through Xero, usually on Net 15 terms. Tallyfy doesn't send payment reminders, so watch your invoices. As an invoice passes its due date, you'll see banners change: * **Overdue (under 30 days)** - an amber banner: "Payment overdue. Please see billing or file a support issue to avoid service disruption." * **Read-only (about 30 days overdue)** - a red banner: "This organization is read-only due to an overdue payment. Settle the invoice in Xero to restore access." ## What read-only mode means In read-only mode, people can still sign in, view processes, download reports, and export data. They can't create templates, launch processes, complete tasks, edit, or invite people. If someone tries a blocked action, they'll see a short message explaining the account is read-only until the payment is settled. ## How to restore access Restoring access is straightforward: * **Invoiced accounts** - pay the overdue invoice through Xero. Tallyfy lifts read-only mode automatically on the next daily sync, usually within about a day. If you need it sooner, [contact Tallyfy Support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/) and we can sync your billing right away. * **Card accounts** - update the card on file in **Settings** > **Billing**. ## Why is my account read-only? The usual reason is an invoice that's about 30 days past due. Settle that invoice (or update your card, if you pay by card), and full access returns automatically once the payment is picked up. Continued non-payment beyond this point may lead to the further consequences described in our [Customer Terms](https://tallyfy.com/legal/). - **[Account and member limits](https://tallyfy.com/products/pro/settings/billing/what-are-tallyfys-account-and-member-limits/)**: Tallyfy has Full Members who create and edit templates, and Light Members who only complete assigned tasks. Guests from outside your organization get unlimited free access to specific tasks. ## Account and member limits Tallyfy has two [member roles](/products/pro/documenting/members/) with different capabilities: * **Full Members** - Can access all features, including creating and editing [templates](/products/pro/documenting/templates/). Includes Admin and Standard roles. * **Light Members** - Can only complete assigned [tasks](/products/pro/tracking-and-tasks/tasks/) and participate in launched processes. They **can't** create or edit templates. An optional Data Feed add-on for [Tallyfy Analytics](/products/pro/integrations/analytics/) is also available. Each Full or Light member uses a paid seat. For how seats are billed, see [how seat billing works](/products/pro/settings/billing/how-seat-billing-works/). ### 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 Tallyfy's free 14-day trial has these limits: * 10 [members](/products/pro/documenting/members/) per account * 10 [guests](/products/pro/documenting/guests/) per account * 100 total [task assignments](/products/pro/tracking-and-tasks/tasks/) across all processes * 10 [processes](/products/pro/tracking-and-tasks/processes/) running at the same time If these limits affect your evaluation, [contact Tallyfy support](/products/pro/miscellaneous/support/how-can-i-contact-tallyfys-support-team/) to discuss an extension. ### Members vs. guests * **Members** - People in your organization (employees, contractors). They're assigned Full or Light roles. * **Guests** - People outside your organization (clients, vendors, partners) who only complete specific [tasks](/products/pro/tracking-and-tasks/tasks/). Guest access is **unlimited** and free. :::note[External domains for partners and consultants] If you're a client organization and external partners or consultants 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 marks those users as "Unbilled" in your organization only - they won't count toward your billed member total. If you're a partner, this doesn't apply to your own Tallyfy organization. Your own account bills all active users normally per your subscription plan. The unbilled domain feature only exempts partner users within the client organizations they support. See [Become a Tallyfy Partner](/products/pro/miscellaneous/how-can-i-become-a-tallyfy-partner/) for details. ::: For full plan details, visit the [pricing page](/products/pro/pricing/). --- ## Metadata - **Generated**: 2026-08-18T14:55:36.228Z - **Total Documents**: 562 - **Products**: Answers, Denizen, 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