To join or not to join, that is the question. The question that Fabian asked himself one cold January morning when facing one of his datasets. Would it be better to merge all the reads from 5 different samples and then generate the transcriptome, or would it be better to call the transcripts per sample and merge the transcript models afterwards? In the first case, it couldn’t be parallelized, and he was not sure the server could handle the memory consumption. On the other hand, the power to detect low-abundance isoforms might increase if merged before calling. I am sure that if you work in transcriptomics, you have asked yourself this same question. And thanks to Fabian’s work, worthy of nothing less than Nature, we have the answer. Come with us on this journey of discovery.
This challenge began with a fundamental methodological choice between two completely different workflows. In the Join & Call (J&C) strategy, you first concatenate all the raw sequencing reads across all biological replicates into a single collective pool, and then you run your transcript reconstruction tool on the combined dataset. Opposed to this, in the Call & Join (C&J) strategy, you initially process each biological sample through the transcript reconstruction tool and then you merge the resulting transcript models using an annotation combiner, such as TAMA merge.
As mentioned earlier, each approach has its inherent advantages and disadvantages. When pooling reads in J&C, you maximize your statistical power to detect rare, low-abundant isoforms, since the one or two reads that are per replicate and do not reach the detection thresholds are combined. However, this comes at the expense of significantly increasing the computational resources and time needed to run the transcriptome reconstruction step, sometimes not being even manageable unless a powerful HPC is available. On the other hand, C&J is suited for parallelization, breaking down the reconstruction step into the samples. However, the concern arises as to whether low-abundance isoforms won’t be discarded as sample-level noise.
To provide an answer for you, so you could stop blowing your brains out, Fabian, Alejandro and the team set up an exhaustive benchmark, so you wouldn’t have to do it ;). They used a dataset consisting of five biologically independent mice across two tissues, with completely different transcriptional complexity: brain and kidney. The samples were sequenced using both Pacific Biosciences (PacBio Sequel IIe) and Oxford Nanopore Technologies (ONT PromethION), spiked in synthetic SIRV controls, and evaluated six widely used transcript reconstruction tools: FLAIR, IsoQuant, Bambu, TALON, Mandalorion and IsoSeq (followed by SQANTI3 to filter out technical artifacts).
🧪 Replicate Strategy Simulator: J&C vs. C&J
Explore how pooling reads vs. calling per-sample impacts novel isoform recovery and server memory
1. Novel Isoform Discovery Favours Join & Call
If your goal is to find new isoforms and unannotated splicing events, say you work in developmental biology, neurobiology or cancer, then J&C is a win-win. If you combine this approach with cluster-based tools like FLAIR, TALON and IsoSeq (with curation from SQANTI afterwards, of course 😉 ), you will recover substantially more novel splice junction chains than with C&J.
The reason is almost embarrassingly simple once you see it. Imagine a novel transcript with one supporting read in each of three replicates. In Call & Join, each sample is judged alone, and a single lonely read looks exactly like sequencing noise, so it gets filtered before the model is even built. TAMA Merge can’t resurrect what was never there. But pool those same reads first, as in Join & Call, and that lonely read becomes three reads of collective support, enough to clear the threshold and make it into the consensus transcriptome. Same data, same reads, completely different fate, just because of when you decided to add them together.
2. Watching your compute budget? Call first.
Of course, Join & Call’s sensitivity doesn’t come free. Pooling everything means asking your reconstruction tool to build one enormous splice graph across the whole cohort, and for tools like TALON and Mandalorion that meant peak memory over 150–200 GB. If you’re sharing a cluster with actual quotas, this can turn “let’s add a few more samples” into IT shutting your run down because the server is on the verge of burning.
Call & Join sidesteps this by design. Each replicate runs on its own, so memory stays in the 20–35 GB range per sample, and the whole thing parallelizes cleanly across your queue. Nobody’s job dies at 3am because the cluster ran out of RAM.
3. The tools don’t all play by the same rules
Here’s where it gets genuinely interesting: how you combine samples interacts with which tool you’re using, sometimes in the opposite direction you’d expect.
IsoQuant breaks the pattern entirely. It actually found more transcript diversity under Call & Join than Join & Call. Because IsoQuant leans on splice-graph inference with local, per-sample correction, small definitional differences between replicates survive independently and get preserved when merged. Pool the reads first, and those same differences just collapse into one shared structure.
Bambu barely notices. Its reference-guided, machine-learning approach prioritizes precision over permissive discovery, so isoform counts stay nearly identical whichever strategy you pick. If you want a tool that shrugs at this whole debate, it’s Bambu.
Relative expression thresholds can punish rare isoforms for succeeding. Tools like Mandalorion and IsoQuant require a candidate to clear not just an absolute read count but a minimum share of the parent gene’s total expression, often around 2%. Under Call & Join, a rare isoform can easily clear that bar in a sample with modest overall expression. Pool everything, and the gene’s dominant isoforms inflate total expression, diluting the rare candidate below 2% and quietly discarding it — the opposite failure mode from the low-read-support problem above.
4. And a word on ground truth: don’t trust the SIRVs alone
One more little twist. Synthetic SIRV spike-ins are the standard technical control, but the team found they paint an overly rosy picture, since they’re shorter and more structurally uniform than real mammalian transcripts. To get a fairer read on pipeline performance, they benchmarked against TUSCO instead, a curated set of endogenous single-isoform genes that actually share the expression ranges, lengths and technical quirks of the rest of your sample. If SIRVs are the easy exam, TUSCO is the one that tests what you actually came here to learn.
So, join or not to join?
The team’s answer, in short:
Chasing novel isoforms or alternative splicing? Join & Call, paired with a permissive tool like FLAIR or IsoSeq (run through SQANTI3 afterward), and make sure your infrastructure can take the memory hit.
Running a large cohort or population study, or differential transcript usage? Call & Join, paired with a conservative tool like Bambu or Mandalorion, for stable quantification without the memory headache.
Benchmarking your own workflow? Don’t rely on SIRVs alone. Bring in TUSCO for a realistic read on precision and sensitivity.
Congratulations to Fabian, Alejandro, Carol, Ana and the whole team on this one. Fabian can finally sleep at night. 👏
Full paper in Nature Communications: Handling biological replicates in long-read RNA sequencing data by joining or not joining (doi: 10.1038/s41467-026-77367-6). 🧬📄