Phylogenetic Tree Construction Explained: Distance, Parsimony, Likelihood, and Bootstraps

Quick answer: multiple sequence alignment, building a phylogenetic tree means deciding which branching pattern and branch lengths best explain how those sequences evolved. Three strategy families exist: distance methods (fast, summaries of pairwise differences), parsimony (fewest changes needed), and maximum likelihood / Bayesian methods (explicit evolutionary models, today’s standard for credible work). No method reads evolution off the data directly; each is a claim about what a good tree looks like — and the bootstrap is the standard honesty check that tells you how much of the tree you actually have evidence for.

Sequel to the reading-a-tree guide on this blog, and the natural downstream step after the MSA and sequence-alignment posts: alignment is the input, tree-building is the inference.

From alignment to tree: what the inference actually is

A multiple sequence alignment of, say, five species gives a matrix of homologous columns. A tree is a hypothesis: a topology (who shares a common ancestor with whom, where the splits happened) plus branch lengths (how much change happened along each edge). infinitely many trees exist for even modest taxa counts — for 50 sequences, the number of possible topologies is beyond astronomical — so no algorithm can simply enumerate them. Every tree-building method is therefore a strategy for searching this space of possibilities under some criterion of what counts as a better tree.

The alignment you start from, not the tree software, decides most of the ceiling: badly aligned columns create “smart-looking” false signal. Filter badly aligned or overly gapped regions, ideally cite homologous function regions, and — for anything broad across a family — check that loci are truly homologous one-to-one.

Distance methods: nearest-neighbor in plain language

Distance methods compress each pair of sequences to a single number (fraction of differences, corrected for multiple hits), and then join the closest pairs first. The classic is neighbor joining (and the biologically neat refinement, minimum evolution):

• Cheap: near-linear computations for many taxa; fine for thousands-of-sequences pipelines, such as clustering large 16S amplicon datasets before deeper analysis.
• Deterministic: one run, one tree; no heavy software or manual tricks.
• Lossy: reducing every sequence to pairwise numbers throws away the specific positions where changes occurred, so the method cannot use patterns in how substitutions actually happen.

Distance-based trees are the standard “quick shape of the data” tool: use them to sanity-check outlier sequences, spot mis-identification, or collapse a 16S dataset before deeper analysis. Primary takeway: reading them as evidence about history only is the rookie mistake — they are summaries, not inferences.

Parsimony: counting the fewest changes

Maximum parsimony asks: given a candidate tree, what is the minimum number of evolutionary changes it needs across all alignment columns? The best tree is the smallest total. Intuition: evolution is generally conservative, so shortest explanation first. Its historical importance is enormous and it still works well for closely related sequences and for morphology-based trees.

Its notorious honest weakness: long-branch attraction — two fast-evolving lineages can end up drawn as sisters merely because both have accumulated many changes, not because they share recent ancestry. When one clade in your data evolves much faster than the rest, parsimony ranks the wrong ancestry with striking confidence, which is extremely seductive to a reader who just sees a clean tree.

Maximum likelihood and Bayesian inference: models, not rules

Maximum likelihood (ML) works the reverse way. A candidate tree plus an evolutionary model (rates of A↔G substitutions, unequal base frequencies, rate variation across sites, etc.) can predict the probability of actually seeing your alignment. ML searches the tree-and-model space for the combination that maximizes that probability. Bayesian methods (MrBayes, RevBayes) ask the similar but Bayesian-idiom question: what is the probability of a tree given the data, and how uncertain is each branch, produced as posterior probabilities after sampling the tree landscape.

The standard contemporary tools:

• RAxML-NG / IQ-TREE 2 — maximum-likelihood, the practical default for most sequence-based analyses; IQ-TREE additionally selects among substitution models automatically.
• MrBayes — Bayesian inference when the uncertainty values and priors are part of the message; the honest rule is that Bayesian posterior probability and ML bootstrap support answer slightly different questions and are reported side by side.
• FastME, distance-based, for scaffolding; PhyML for simpler, older pipelines.

What you buy with ML/Bayesian: explicit models that are honest about substitution rate, the option of partitioned models (e.g., separate amino-acid models for protein domains, separate codon models), branch-length uncertainty, and — critically — per-branch support values that mean something.

Support values: what actually is trustworthy

Any of these methods can tell you a best tree; support values tell you how much data underwrite each branch:

• Bootstrap (distance, parsimony, ML): resample alignment columns with replacement (say, 100 times), rebuild a tree each, report for each branch how often it appears in the re-sampled trees. A branch found in ~95% of replicates is well supported; ~50–70% is genuinely uncertain and should be drawn accordingly and NOT silently pruned.
• Posterior probabilities (Bayesian): typically printed on the same tree; a probability of 0.95 is usually taken as strong.
• Ultrafast bootstrap / SH-aLRT: the fast approximations that modern ML tools compute internally so support can be shown from a single search.

The clean discipline that saves beginners: do exactly nothing with branches whose support leaves you unsure — mark them in the figure, mention them in the text, and let the uncertainty stand. A completely resolved, immaculately drawn tree of mostly low-support splits is less honest than a partially bifurcating tree that says where evidence breaks down.

Choosing a method honestly

• Many sequences, routine or exploratory — distance/neighbor-joining, or a fast ML setup, for shape-of-data overviews.
• A fully sequenced, well-aligned set of related taxa you plan to interpret — maximum likelihood with a chosen or auto-selected model, bootstraps, and partitions if appropriate.
• A single-molecule inference with discrete, defensible assumptions that you want to average over explicitly — Bayesian.
• A result you intend to publish — regardless of what method you picked, show the support values and name the model. A tree without support values is a figure, not a result.

Beginner traps that fabricate trees that look real

• Building the tree from an unrevised alignment. Poorly aligned or non-homologous regions dominate the distance. Trim or hand-edit before anything else.
• Mixing short and long branches in one parsimony analysis and reading the result as ancestry — the long-branch-attraction failure surfaces exactly here.
• Reporting one tree, no support values. A tree without bootstraps or posterior probabilities is not interpretable, because you cannot see which parts are genuinely drawn from data.
• Interpreting branch order as time. Nothing in a raw topology is a clock; time calibration needs a molecular clock model and calibration points, an additional technique.
• Calling a high-support clade the “true” history. High support means the data consistently describe that relationship — the data could still be wrong about the evolutionary mechanism (model misspecification persists, and all tree methods inherit weaknesses of the alignment).
• Using ML/Bayesian on a dataset or semantic class with structural problems — contamination, paralogy, or horizontal gene transfer can create coherent, high-support branches with no species history at all.

Key takeaways

• Tree building is an inference over an enormous hypothesis space, and every method encodes a claim about what a better tree is; nothing reads history off the alignment directly.
• Distance methods are summaries: fast and cheap, right for quality control and shape-of-data overviews, but not usually the method of record.
• Parsimony counts changes and is intuitive, but reads wrong ancestries when evolutionary rates differ (long-branch attraction).
• ML and Bayesian methods dominate today because explicit evolutionary models and branch support make their results interpretable; IQ-TREE 2 and RAxML-NG are the workhorses.
• Bootstrap or posterior support values, reported per branch, determine what in a tree is evidence and what is just drawn — reporting them is not optional.
• The alignment you feed in, and the choices you make when filtering it, limit what any downstream method can recover.

Challenge

Download a small curated alignment of 16S rRNA sequences (a dozen taxa) from a public database, or take an example alignment shipped with IQ-TREE. Build three trees: neighbor joining (e.g., with FastME or the R package ape), maximum likelihood (IQ-TREE default), and — if you are curious — a Bayesian run. Compare topologies and, above all, the support values. Where the methods agree with strong support, the relationship is solid; where they clash, you have found exactly the branches requiring closer alignment, more data, or faster/slower-rate modeling scrutiny.

Want hands-on practice building and interpreting trees for your own sequences? Ampersand Academy offers one-to-one mentoring in bioinformatics — part of Mahadhi, a development and digital marketing company.

FAQ