Summary
- This is a re-author, not a data export - Trainual is documentation and Tallyfy is execution, so you’re not importing a structure, you’re rebuilding the procedures that have to actually get done as runnable processes.
- The export tells you that plainly - Trainual exports content to PDF at the subject, document, and flowchart level, but tests, videos, checklists, and courses can’t be exported, and the API manages people and assignments, not content.
- Keep Trainual for the reading, move the doing - documentation that someone reads and acknowledges stays useful; the onboarding tasks that must actually happen belong in a workflow tool.
- Reckon on a few weeks for the procedures - separating what to keep from what to rebuild is the slow part. Book a 30-minute migration walkthrough and we’ll be honest about what should move and what shouldn’t.
Moving from Trainual to Tallyfy isn’t really a migration, and treating it like one will set you up to fail. The real shape of it is this: Trainual is where you write down how the business runs, and Tallyfy is where that work actually gets run and tracked. The two are adjacent, not rivals. So this guide is less about exporting data and more about deciding which of your documented procedures need to become live, accountable processes, which is the same question underneath choosing a workflow tool at all.
Split your Trainual content into two groups before you do anything else. One group is reference: policies, the company handbook, training material people read once and look up later. That can stay documentation. The other group is procedures that must actually happen, with someone responsible and a way to prove each step got done. Those are what you rebuild in Tallyfy. The line between “read this” and “do this” is the whole migration.
Why teams add Tallyfy alongside Trainual
Trainual is good at what it’s built for, and I want to be fair about that before talking about the gap. It documents how a business runs, it gives new hires something structured to read, and it keeps your playbook searchable in one place. As a knowledge base, it does the job.
The gap is the difference between describing work and doing it. Documentation tells someone how a process should go; it doesn’t make the process happen or show you whether it did. A new hire reads the onboarding subject and clicks to acknowledge it. Fine. But did IT actually create the account? Did the manager actually run the first one-on-one? Did anyone collect the signed policy?
Reading and acknowledging is not the same as doing and tracking, and Trainual lives firmly on the reading side of that line.
That’s why this is a complement, not a rip-out. Trainual documents how the work is done; Tallyfy runs it. A team that has carefully written up its onboarding in Trainual is in a great position to make it executable, because the thinking is already done. What’s missing is the part that turns a written procedure into a tracked run where each step has an owner, a due date, and a record that it happened, rather than a follow-up you cobble together from memory each time. You’re not throwing the documentation away. You’re giving the parts that matter a place to actually execute.
What Trainual’s export actually gives you
Lead with the export reality, because it’s a harder truth here than with most tools, and it shapes the whole plan. Trainual lets you export and print content as a PDF at the subject, document, and flowchart level, which is useful for a backup or a read-through. But the same page is honest about the limits: tests, standalone videos, checklists, premium courses, and standalone files can’t be printed or exported as a PDF. So a PDF gets you the written procedures and not much else.
The API doesn’t fill the gap either. Trainual’s own documentation says the API is for managing people and assigning content, and states plainly that you cannot view, edit, or create any content through it. Read that twice, because it’s the load-bearing fact of this whole move, and a painful one: there is no clean pipe that pulls your content out in a structured form. The API can shuffle who’s assigned to what, but it can’t hand you the procedures themselves.
Put those two facts together and the conclusion is unavoidable. This is a re-author, not an import. You read your Trainual procedures, usually as PDFs or just on screen, and you rebuild the ones worth running as Tallyfy templates by hand. That sounds like more work than a one-click migration, and it is, but it’s also the moment you get to fix the procedures that quietly went stale instead of copying them across unchanged.
Employee Onboarding and Orientation Made Easy
How Trainual concepts map to Tallyfy
The shapes don’t line up the way a form-to-form move does, because you’re crossing from documentation into execution. Here’s how the pieces translate.
| In Trainual | In Tallyfy | What actually changes |
|---|---|---|
| Subject / Topic | Blueprint | A documented procedure becomes a runnable one |
| Step (the content) | Step (with a task) | Reading turns into something someone has to do |
| Process / Policy | Blueprint or reference | The “how” becomes the “do it now,” or stays read |
| Test / quiz | Validation or approval | Acknowledgement becomes a checked gate |
| Role / assignment | Group + assignee | Who should know becomes who must do |
| Onboarding track | Onboarding blueprint | A reading path becomes a tracked run |
The mental shift is that Trainual answers “how is this done?” and Tallyfy answers “is it being done, by whom, and where is it stuck?” A Trainual step that explains how to set up a new account becomes a task with an owner and a due date, so you turn each step into a task someone owns rather than a paragraph someone skims. A quiz that confirmed a new hire read the safety policy becomes a real gate in the process, not a score in a report. And the onboarding track that someone used to read top to bottom becomes a run where you can see where each new hire is stuck at any moment.
Take new-hire onboarding, since that’s where this clicks for most teams. In Trainual, you’ve got a beautiful onboarding subject: welcome content, the org chart, how-we-work topics, a policy or two with a quick test at the end. A new starter reads it, clicks through, and Trainual records that they finished it. Good so far, except finishing the reading isn’t the same as being onboarded.
In Tallyfy, that same onboarding becomes a process that runs. The welcome reading can stay in Trainual and get linked from a step. But the actual tasks become tracked work: IT provisions the laptop and accounts, facilities sorts the desk, the manager books and runs the first one-on-one, HR collects the signed documents, and each of those has an owner and a deadline. The policy test becomes an approval gate that the run can’t pass until it’s cleared. You’ve moved from “the new hire read about onboarding” to “onboarding is happening, here’s exactly where, and here’s what’s late.” That’s documented turning into executed, which is the entire reason to make the move.
A realistic migration timeline
Reckon on a few weeks for the procedures, because re-authoring takes longer than exporting ever would. This is the slower end of any migration, and that’s fine, because the work is mostly judgment rather than typing.
Spend the first week sorting, not building. Go through your Trainual content and split it hard: this is training to keep as reading, that is a procedure that has to execute. Resist the urge to convert everything, because most of a Trainual account is content, not process. Then over the next couple of weeks, rebuild the executable procedures as Tallyfy templates, starting with the one that hurts most when it goes wrong, which for most teams is onboarding. Where the content genuinely belongs in Trainual, leave it there and link to it from the relevant step.
Run one real instance through end to end before you trust it, ideally a real new hire or a real version of whatever process you started with. The first one is slow because you’re learning the moves; the rest go quicker.
Why not just move everything across?
Because a training video doesn’t become more useful by living in a workflow tool, and most of Trainual is exactly that kind of content. Move what has to be done and tracked. Leave what has to be read where reading already works.
What breaks, and what Tallyfy won’t replace
Several things stay behind, and you should go in knowing them. Embedded videos and courses don’t transfer, because a workflow tool has no concept of a course you sit through. The knowledge-base reading experience, the searchable handbook feel, isn’t what Tallyfy is for. Completion semantics differ too: Trainual’s “I read this” is not Tallyfy’s “I did this and here’s the proof,” and that’s a feature of the move, not a bug. Some org-chart and role features carry over only partly.
Here’s where Tallyfy bows out and Trainual keeps going. Three things, really: training and LMS-style content authoring, courses, and the knowledge-base reading experience. Tallyfy is a workflow engine, not a training platform, and it isn’t pretending otherwise. So your company handbook, your “how we think about customer service” training, the genuinely educational material that people read to learn rather than to act, that has a good reason to stay in Trainual. Move the procedures whose value is the work getting done; keep the content whose value is someone learning from it. Running both on purpose is a perfectly sane setup, with Trainual as the library and Tallyfy as the execution layer that proves the work happened.
Tracked and enforced, not described and ignored.
What we tend to find is that the real complaint behind a Trainual move isn’t about Trainual at all. It’s that documenting a process and running a process are two different jobs, and a docs tool was only ever doing the first one. People wrote everything down, assumed that meant it would happen, and then it turns out a checked-off reading is not a finished task. The fix isn’t a better handbook. It’s giving the procedures that matter a place to actually run, with owners and proof, while the reference material stays exactly where it reads well. AI sharpens the point too, because a defined, running process is something a model can help carry out instead of guessing at, where a static document gives it nothing to hold onto.
Common questions about migrating from Trainual
Is moving from Trainual to Tallyfy a real migration or a rebuild?
Can I export my content out of Trainual?
What happens to my training videos and courses?
Should I move everything out of Trainual?
How does the pricing compare?
Still weighing it up rather than committed? Our Trainual alternative comparison covers the positioning feature by feature, and this guide is the execution half of that comparison. If the deeper issue is that your onboarding gets read and then ignored, why new hires tune out training gets at the same root problem from the other side.
When you want to plan the real thing, the fastest start is a short call where we look at one procedure you’ve documented in Trainual and work out whether it should run as a Tallyfy process or stay a written reference.
Book a 30-minute migration walkthrough and bring the procedure that gets documented but never quite happens. That’s the clearest way to see the fit.
