Skip to content
Tallyfy

Migration guide

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 ↗[1].

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

  1. Clone and install.

    Terminal window
    git clone https://github.com/tallyfy/migrator.git
    cd migrator
    pip install -r requirements.txt

  2. Configure environment variables.

    Terminal window
    cp .env.template .env
    # Edit .env with: TALLYFY_API_KEY, TALLYFY_ORGANIZATION, and the source vendor's API keys

  3. Run a dry run first.

    Terminal window
    # Example: Asana
    cd asana/src
    python main.py --dry-run --verbose

  4. Review the report. Confirm mappings, spot errors, and check rate-limiting notes. Adjust batch sizes or delays if needed.

  5. Run the actual migration.

    Terminal window
    python main.py

  6. Validate and spot-check. Use the generated report and sample records in Tallyfy. If anything fails mid-way, use --resume.

  7. (Optional) Enable AI-assisted mapping. Add AI_ENABLED=true and an AI API key in .env to improve field and structure mapping for complex vendors.

Vendor-by-vendor notes and caveats

Each folder links to the open-source code for that vendor, with scope and common considerations.

  • Asana: Folder ↗[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 ↗[3]

    • Scope: To-dos and lists → procedure templates and steps; message docs are typically referenced via links.
    • Caveats: Threads/comments are not 1:1 with Tallyfy task comments; attachments may be copied by URL.

  • ClickUp: Folder ↗[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 ↗[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 ↗[6]

    • Scope: Questions and responses.
    • Caveats: Simple structure migrates well; logic jumps may require manual checks. Low complexity.

  • Jotform: Folder ↗[7]

    • Scope: Forms, fields, and submissions.
    • Caveats: Rich widgets may need custom mapping. Watch for attachment handling and rate limits.

  • Kissflow: Folder ↗[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 ↗[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 ↗[10]

    • Scope: Processes and tasks.
    • Caveats: Step logic and automations may need manual review. Confirm user-role mapping.

  • Pipefy: Folder ↗[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 ↗[12]

    • Scope: Checklists, tasks, conditional logic.
    • Caveats: Complex conditions translate to Tallyfy automations. Medium complexity; validate branching.

  • Rocketlane: Folder ↗[13]

    • Scope: Project templates and tasks.
    • Caveats: Timeline and resource views don’t directly map. Focus on steps and assignments.

  • Trello: Folder ↗[14]

    • Scope: Boards, lists, cards → templates and steps.
    • Caveats: Checklists and labels map to steps/metadata. Butler automations require manual recreation.

  • Typeform: Folder ↗[15]

    • Scope: Forms and responses.
    • Caveats: Logic jumps translate where feasible. Low complexity.

  • Wrike: Folder ↗[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. From there, you launch processes and track them as live processes with individual tasks. Use automations to recreate conditional behavior from the source system.

Pro > Integrations

Tallyfy offers twelve distinct ways to connect with your existing business software — ranging from a full REST API and webhooks for developers to no-code middleware platforms like Zapier and Make for non-technical users — along with email integration and chat tools like Slack and upcoming BYO AI capabilities so every team can automate data sharing and eliminate manual copy-pasting between systems regardless of technical skill level.

Integrations > Middleware

Tallyfy connects to thousands of business apps through middleware platforms like Zapier and Make.com using visual drag-and-drop tools that require no coding and let you automatically launch processes and sync data between systems in minutes.

Templates > Import a template

Tallyfy lets you import templates from Word docs, PDFs, PowerPoint files, flowchart images, or other Tallyfy accounts using AI that converts even 50-page SOPs into working templates in seconds and replaces dozens of duplicate PowerPoint playbook versions with a single dynamic template featuring conditional logic and smart branching.

Middleware > Integrate to your CRM or ERP

Tallyfy integrates with CRM and ERP systems like Salesforce and NetSuite through middleware or magic links so that the dozens of invisible micro-tasks happening between sales stages—like technical reviews and legal approvals and resource checks—become visible and trackable with auto-assignment and deadline enforcement for everyone involved including teams outside the CRM.
Get in touch
About Tallyfy