# Genome Sequencing and Assembly: Methods, Challenges, and Best Practices

## Introduction to Genome Sequencing and Assembly

Genome sequencing and assembly is the process of determining the complete DNA sequence of an organism's genome and reconstructing the order of nucleotides from fragmented sequencing data. The central goal is to produce a contiguous, accurate representation of the genome—ideally a single sequence per chromosome—from millions of short or long reads that individually cover only a small fraction of the genome.

The workflow begins with DNA extraction, followed by library preparation, where the DNA is fragmented and adapter sequences are ligated to the ends. The library is then loaded onto a sequencing platform that generates reads—short or long nucleotide sequences derived from individual DNA fragments. These reads are the raw material for assembly, which computationally reconstructs the original genome by identifying overlaps between reads and building longer contiguous sequences called contigs. Contigs are then ordered and oriented into scaffolds using additional information such as paired-end distances or chromatin conformation data.

The assembly problem is fundamentally a computational challenge: given a set of reads, reconstruct the original sequence from which they were derived. This is complicated by several biological realities. Genomes contain repetitive sequences that are longer than the reads themselves, making it impossible to unambiguously determine how those repeats connect. Sequencing errors introduce mismatches that can break overlaps or create false connections. And for diploid or polyploid organisms, the presence of allelic variation between homologous chromosomes complicates the reconstruction, as the assembler must decide whether divergent sequences represent separate loci or alleles of the same locus.

### The Sequencing Revolution

The field has evolved through three major technological phases. First-generation sequencing, exemplified by Sanger sequencing, produced reads of 500–1,000 base pairs with very high accuracy, but at a cost and throughput that limited its application to small genomes or targeted regions. The [Sanger Sequencing Protocol](/knowledge/molecular-biology/sanger-sequencing-protocol) remains relevant for validation and finishing, but it is not scalable to whole-genome projects.

Second-generation sequencing, dominated by Illumina platforms, introduced massively parallel short-read sequencing. These instruments generate hundreds of millions of reads of 100–300 base pairs in a single run, with per-base error rates below 0.1%. The dramatic reduction in cost per base made whole-genome sequencing feasible for any laboratory, but the short read length created substantial challenges for assembly, particularly in repeat-rich genomes.

Third-generation sequencing, represented by Pacific Biosciences (PacBio) and Oxford Nanopore Technologies (ONT), produces reads of 10–100 kilobases or longer. These long reads can span entire repetitive elements and resolve structural variation, dramatically improving assembly contiguity. The trade-off is lower per-base accuracy, though recent improvements in both chemistry and computational error correction have narrowed this gap considerably.

### From Reads to Genome: The Assembly Problem

The assembly problem can be stated formally: given a set of reads R = {r₁, r₂, ..., rₙ}, find the sequence S such that every read in R is a substring of S (or a substring of its reverse complement), and S is the shortest such sequence. This is a version of the shortest common superstring problem, which is NP-hard in its general form. Real assemblers therefore use heuristic approaches that exploit the structure of sequencing data.

Two fundamental algorithmic paradigms have emerged: overlap-layout-consensus (OLC), which works by finding pairwise overlaps between reads and building a graph where reads are nodes and overlaps are edges; and de Bruijn graphs, which decompose reads into shorter k-mers and build a graph where k-mers are nodes and adjacent k-mers are connected by edges. The choice of paradigm is closely tied to the sequencing technology: OLC is natural for long reads, where the number of reads is small enough that pairwise comparison is tractable, while de Bruijn graphs are efficient for short reads, where the sheer number of reads makes all-pairs overlap detection computationally prohibitive.

## Sequencing Technologies and Their Outputs

The choice of sequencing platform determines the read length, accuracy, throughput, and cost—parameters that directly shape the assembly strategy. Understanding these characteristics is essential for selecting the appropriate technology and assembler for a given project.

### Short-Read Sequencing (Illumina)

[Illumina sequencing](/knowledge/diagnostics/molecular/illumina-sequencing-principle-chemistry-and-workflow) uses sequencing-by-synthesis chemistry. DNA fragments are attached to a flow cell, amplified into clonal clusters via bridge amplification, and then sequenced by adding fluorescently labeled nucleotides one at a time. Each incorporation event is detected as an image, and the sequence is called from the fluorescence signals across successive cycles.

Typical Illumina reads are 150 base pairs (paired-end) or 250 base pairs (longer read kits), with per-base error rates of 0.1–1%. The dominant error type is substitution, particularly at the ends of reads where signal decay reduces base-calling confidence. Throughput ranges from a few gigabases for benchtop instruments like the MiSeq to several terabases for the NovaSeq X series. The high accuracy and low cost per base make Illumina the workhorse for most genomics applications, including resequencing, variant calling, and [transcriptomics](/knowledge/bioinformatics/modern-transcriptomics-bulk-single-cell-spatial).

For assembly, the key limitation is read length. A 150-base-pair read cannot span a complete Alu element (approximately 300 base pairs), let alone larger repeats such as LINE-1 elements (6–7 kilobases) or segmental duplications (10–300 kilobases). This means that short-read assemblies are inherently fragmented in repeat-rich regions. Paired-end sequencing partially mitigates this by providing information about the distance and orientation between two reads from the same fragment, but the insert size is typically limited to 300–700 base pairs, which does not resolve larger repeats.

### [Long-Read Sequencing](/knowledge/bioinformatics/long-read-sequencing-technologies-pacbio-and-oxford-nanopore) (PacBio, Oxford Nanopore)

PacBio sequencing uses single-molecule real-time (SMRT) technology. A single DNA polymerase molecule is immobilized at the bottom of a zero-mode waveguide, and as it incorporates fluorescently labeled nucleotides, the fluorescence is detected in real time. The continuous read length can exceed 100 kilobases, with an average of 15–25 kilobases for standard libraries. The raw read accuracy is approximately 85–92%, with errors distributed randomly across the read. However, the circular consensus sequencing (CCS) mode, also known as HiFi sequencing, reads the same molecule multiple times by using a hairpin adapter, producing reads of 10–25 kilobases with accuracy exceeding 99.9%.

[Oxford Nanopore sequencing](/knowledge/bioinformatics/oxford-nanopore-sequencing-from-sample-to-base-calls) passes a single DNA strand through a protein nanopore embedded in a membrane. As nucleotides pass through the pore, they cause characteristic disruptions in an ionic current, which are decoded into a sequence. Read lengths are limited only by the length of the DNA molecule presented to the pore, and reads exceeding 2 megabases have been reported. The raw read accuracy is 90–98% depending on the chemistry and base-calling model, with errors dominated by insertions and deletions rather than substitutions. Recent R10.4 pore versions and improved base-calling algorithms have pushed modal accuracy above 99%.

The key advantage of long reads for assembly is their ability to span repetitive elements. A 20-kilobase PacBio HiFi read can cross multiple Alu elements, LINE-1 elements, and even large segmental duplications, providing unambiguous connections between unique flanking sequences. This dramatically reduces the number of assembly gaps and produces contigs that approach chromosome-arm length. The trade-off is higher cost per base and lower throughput compared to Illumina, though the gap has narrowed substantially in recent years.

## Assembly Algorithms: Overlap-Layout-Consensus and De Bruijn Graphs

The two dominant algorithmic approaches to genome assembly—overlap-layout-consensus and de Bruijn graphs—make different trade-offs between computational efficiency and information utilization. Understanding their mechanisms is essential for choosing the right assembler and interpreting its output.

### Overlap-Layout-Consensus (OLC) for Long Reads

The OLC approach proceeds in three stages. In the overlap stage, all pairs of reads are compared to identify significant overlaps—regions where the suffix of one read matches the prefix of another. For a dataset of n reads, this requires O(n²) pairwise comparisons, which is computationally feasible for long-read datasets (typically 10⁵–10⁶ reads) but prohibitive for short-read datasets (10⁸–10⁹ reads). To accelerate this step, most implementations use indexing strategies such as minimizers or suffix arrays to identify candidate overlapping pairs before performing detailed alignment.

In the layout stage, the overlaps are used to build a graph where reads are nodes and overlaps are edges. The graph is then simplified by removing transitive edges (overlaps that are implied by a path through other reads) and resolving branching structures. The goal is to identify a path through the graph that represents the underlying genome sequence. This is complicated by repeats, which create cycles in the graph, and by sequencing errors, which create spurious branches.

In the consensus stage, the multiple reads that cover each position in the layout are aligned to produce a single high-quality consensus sequence. This step leverages the redundancy of coverage to correct sequencing errors. For PacBio HiFi reads, which already have high accuracy, the consensus step is relatively straightforward. For noisy long reads such as raw ONT or standard PacBio continuous long reads, the consensus step is critical and computationally intensive, often using hidden Markov models or partial order alignment to combine the evidence from multiple reads.

The primary strength of OLC is that it uses the full read sequence, including information about read length and the exact positions of overlaps. This makes it well-suited for long reads, where the read length itself provides valuable information for resolving repeats. The primary weakness is computational cost: the O(n²) overlap detection becomes intractable for very large datasets, and the graph simplification steps are complex to implement correctly.

### De Bruijn Graphs for Short Reads

De Bruijn graph assemblers take a fundamentally different approach. Instead of comparing full reads, they decompose each read into overlapping k-mers—substrings of length k. A graph is constructed where each distinct k-mer is a node, and an edge connects two k-mers if they overlap by k−1 bases (i.e., the suffix of one equals the prefix of the other). The genome sequence corresponds to a path through this graph, and assembly becomes the problem of finding such paths.

The key insight is that the de Bruijn graph compresses the data: instead of storing n reads, the graph stores only the distinct k-mers, which is typically far fewer. This makes the approach scalable to the enormous datasets produced by short-read sequencers. The graph construction requires O(n) time, and the memory footprint is manageable with efficient data structures such as hash tables or Bloom filters.

However, the de Bruijn graph has important limitations. The choice of k is critical: larger k values produce more specific k-mers that are less likely to appear by chance, but they also require longer reads and are more sensitive to sequencing errors. Smaller k values are more robust to errors but create more branching in the graph due to repetitive k-mers. Most assemblers use k values of 21–127, and some use multiple k values in a hierarchical manner.

Sequencing errors create "tips"—dead-end branches in the graph where an erroneous k-mer does not connect to the rest of the graph. These are typically removed by a tip-clipping step. Repeats create "bubbles"—alternative paths through the graph that correspond to different copies of a repeat or to allelic variants. The assembler must decide whether to merge these paths (for haploid genomes) or keep them separate (for diploid genomes). This is one of the most challenging aspects of de Bruijn graph assembly.

The final step is to traverse the graph to extract contigs. This involves finding paths through the graph that are unambiguous—where each node has exactly one incoming and one outgoing edge. These unambiguous paths are called unitigs, and they form the initial contigs. The unitigs are then extended and joined using paired-end information to produce longer contigs and scaffolds.

## Preprocessing and Quality Control of Sequencing Reads

The quality of the assembled genome depends critically on the quality of the input reads. Preprocessing steps remove artifacts, correct errors, and filter contaminants, all of which reduce the complexity of the assembly problem and improve the accuracy of the final product.

### Read Trimming and Filtering

The first step in preprocessing is to assess read quality. For Illumina data, this is typically done with FastQC, which reports per-base quality scores, GC content, adapter contamination, and other metrics. Reads with low average quality (e.g., Phred score below 20, corresponding to an error rate of 1%) should be removed or trimmed.

Adapter trimming is essential for short reads. During library preparation, adapter sequences are ligated to the ends of DNA fragments. If the fragment is shorter than the read length, the sequencer will read through into the adapter sequence, producing reads that contain adapter sequence at the 3' end. Tools such as Trimmomatic or cutadapt identify and remove these adapter sequences. The standard approach is to scan the read for a sequence that matches the adapter with a small number of mismatches, then truncate the read at that point.

For long reads, the preprocessing is different. PacBio reads are produced as a continuous read from a single polymerase molecule, and the quality varies along the read. The SMRT Analysis software identifies and removes low-quality regions, and for HiFi reads, the circular consensus algorithm generates a single high-quality read from the multiple passes. For ONT reads, base-calling quality scores are used to filter reads, and tools such as Porechop remove adapter sequences and identify chimeric reads—reads that contain sequence from two different DNA molecules joined together.

### Error Correction Strategies

Error correction is the process of identifying and correcting sequencing errors before assembly. The strategy depends on the sequencing technology and the assembly algorithm.

For short reads, error correction is often implicit in the assembly process. De Bruijn graph assemblers handle errors by removing tips and correcting k-mers that are present at low frequency. However, explicit error correction can improve results. The most common approach is k-mer-based correction: the set of all k-mers in the dataset is counted, and k-mers that appear at very low frequency (typically 1–2 times) are assumed to contain errors. Reads containing these rare k-mers are then corrected by replacing the erroneous k-mer with a high-frequency k-mer that differs by a single nucleotide. Tools such as BFC and Lighter implement this approach efficiently.

For long reads, error correction is more complex. Raw PacBio and ONT reads have error rates of 5–15%, which is too high for direct assembly with OLC algorithms that rely on exact or near-exact overlaps. Two strategies are used. The first is self-correction, where the long reads are aligned to each other and a consensus is computed. This is computationally intensive but does not require any additional data. The second is hybrid correction, where short reads are aligned to the long reads and used to correct errors. This is more accurate but requires sequencing the same sample on both platforms.

The emergence of PacBio HiFi reads has largely eliminated the need for error correction in long-read assembly. HiFi reads have accuracy above 99.9%, comparable to short reads, and can be assembled directly without a correction step. This has simplified the assembly workflow considerably and is one of the reasons HiFi sequencing has become the preferred technology for de novo genome assembly.

## Scaffolding and Genome Finishing

The initial assembly produces contigs—contiguous sequences that are internally consistent but whose order and orientation relative to each other are unknown. Scaffolding uses additional information to order and orient the contigs, producing longer sequences called scaffolds. The final steps of genome finishing close gaps between contigs and polish the sequence to eliminate residual errors.

### Paired-End and Hi-C Data for Scaffolding

The most common scaffolding approach uses paired-end reads. During library preparation, DNA fragments of a known size distribution are sequenced from both ends, producing pairs of reads that are separated by a known distance (the insert size). When the two reads of a pair map to different contigs, the insert size provides information about the relative order and orientation of those contigs. If the insert size is larger than the gap between the contigs, the reads must be on the same chromosome, and their orientation constrains the relative orientation of the contigs.

Scaffolding algorithms such as SSPACE and OPERA use this information to build a scaffold graph, where contigs are nodes and paired-end links are edges. The graph is then searched for paths that are consistent with the insert size constraints. The result is a set of scaffolds, each containing multiple contigs separated by gaps of known size.

For chromosome-level scaffolding, Hi-C data is the method of choice. Hi-C captures the three-dimensional conformation of chromatin by crosslinking DNA-protein complexes, digesting the DNA, and sequencing the ligated junctions. The frequency of contacts between two genomic loci is inversely related to their linear distance along the chromosome. This information can be used to order and orient contigs into chromosome-scale scaffolds. Tools such as HiRise and 3D-DNA use Hi-C contact maps to place contigs, and the resulting scaffolds often correspond to entire chromosome arms.

### Gap Closure and Polishing

After scaffolding, the assembled genome contains gaps—regions where the sequence is unknown. These gaps are represented as runs of Ns in the scaffold. Gap closure is the process of filling these gaps with actual sequence.

The simplest approach is to use paired-end reads that span the gap. If a read pair has one read in each of the flanking contigs, the insert size can be used to estimate the gap size, and any reads that map to the gap region can be assembled to fill it. For long reads, the approach is more direct: a single long read that spans the gap provides the complete sequence. This is one of the major advantages of long-read sequencing—the ability to close gaps that are refractory to short-read assembly.

Polishing is the final step, where the assembled sequence is refined to correct residual errors. For long-read assemblies, polishing is essential because the raw reads contain errors that are propagated into the consensus sequence. The most common tool is Racon, which aligns reads to the assembly and computes a new consensus. For PacBio HiFi assemblies, polishing with HiFi reads can achieve accuracy above 99.99%. For ONT assemblies, polishing with Illumina short reads is often recommended, as the short reads provide independent, high-accuracy evidence that can correct systematic errors in the long-read base calling.

## Evaluating Assembly Quality

Assembly quality is assessed along three dimensions: contiguity (how long the assembled sequences are), completeness (how much of the genome is represented), and correctness (how accurate the sequence is). A combination of metrics and tools is used to evaluate these properties.

### Contiguity Metrics (N50, L50)

The most widely used contiguity metric is N50. To compute N50, the contigs are sorted by length from longest to shortest, and the N50 is the length of the contig at which the cumulative length reaches 50% of the total assembly length. In other words, half of the assembled bases are in contigs of length N50 or longer. A related metric is L50, which is the number of contigs needed to reach 50% of the assembly length. A higher N50 and a lower L50 indicate a more contiguous assembly.

For example, if an assembly has a total length of 100 megabases and an N50 of 5 megabases, then half of the assembly is contained in contigs of 5 megabases or longer. A genome assembled with long reads might have an N50 of 10–50 megabases, while a short-read assembly of the same genome might have an N50 of only 50–500 kilobases.

It is important to note that N50 is a length-weighted metric, not a count-weighted metric. A single very long contig can inflate the N50 even if most contigs are short. For this reason, N50 should be reported alongside the total number of contigs and the total assembly length.

### Completeness and Correctness Assessment

Contiguity metrics say nothing about whether the assembly contains all of the genome or whether the sequence is correct. Completeness is typically assessed using BUSCO (Benchmarking Universal Single-Copy Orthologs). BUSCO uses a set of genes that are expected to be present as single copies in the target genome, based on ortholog databases for the appropriate taxonomic group (e.g., vertebrates, arthropods, plants). The assembled genome is searched for these genes, and the proportion that are found complete, fragmented, or missing is reported. A high-quality assembly should have >95% complete BUSCOs.

Correctness is more difficult to assess. The most common approach is to map the sequencing reads back to the assembly and check for consistent coverage and alignment. Regions with abnormally high or low coverage may indicate misassemblies. For short-read data, the proportion of reads that map to the assembly and the proportion of properly paired reads are useful indicators. For long-read data, the alignment of individual reads to the assembly can reveal structural errors, such as mis-joins or inverted regions.

A more rigorous approach is to compare the assembly to a reference genome, if one is available. This can identify large-scale errors such as mis-ordered contigs or mis-assembled repeats. However, for non-model organisms without a reference, this is not possible, and the assessment must rely on internal consistency metrics and BUSCO.

## Hybrid Assembly Approaches

Hybrid assembly combines data from multiple sequencing platforms to leverage the strengths of each. The most common combination is short reads (Illumina) for accuracy and long reads (PacBio or ONT) for contiguity. Hybrid approaches are particularly valuable when long-read sequencing is available but the read accuracy is insufficient for direct assembly, or when the budget allows for a small amount of long-read data to supplement a larger short-read dataset.

### Short-Read + Long-Read Hybrid Assembly

There are two main strategies for hybrid assembly. The first is error correction followed by long-read assembly. In this approach, short reads are used to correct errors in the long reads, and the corrected long reads are then assembled using an OLC assembler. The error correction step can be performed with tools such as LoRDEC or FMLRC, which use de Bruijn graphs constructed from the short reads to identify and correct errors in the long reads. The corrected long reads are then assembled with an assembler such as Canu or Flye.

The second strategy is to assemble the short reads into contigs first, then use the long reads to scaffold and join these contigs. This approach is less common because short-read assemblies are already fragmented, and the long reads are used to bridge gaps between short-read contigs. Tools such as LINKS and SSPACE-LongRead implement this strategy. The advantage is that the short-read contigs are highly accurate, and the long reads provide the long-range information needed to order and orient them.

### Long-Read Scaffolding of Short-Read Assemblies

A related approach is to use long reads solely for scaffolding, without attempting to correct or assemble them. In this strategy, the short reads are assembled into contigs using a de Bruijn graph assembler, and then the long reads are aligned to the contigs. A single long read that aligns to two different contigs provides evidence that those contigs are adjacent in the genome, and the alignment positions provide information about their relative orientation.

This approach is computationally efficient because it avoids the expensive error correction step. However, it is limited by the accuracy of the long reads: if the long reads contain too many errors, the alignments to the contigs may be unreliable. With modern ONT reads, which have accuracy above 95%, this approach can be quite effective. Tools such as npScarf and RagTag implement long-read scaffolding.

## Common Pitfalls and Practical Considerations

Genome assembly is a complex process with many opportunities for error. Understanding the common pitfalls can save time and prevent the production of a low-quality assembly.

### Repeats and Heterozygosity

Repeats are the fundamental challenge of genome assembly. When a repeat is longer than the reads, the assembler cannot determine which copy of the repeat connects to which flanking sequence. This creates ambiguous paths in the assembly graph, and the assembler must make a choice. If the choice is wrong, the resulting contig will be a chimera—a sequence that joins regions that are not adjacent in the genome.

The severity of the repeat problem depends on the genome. Bacterial genomes have few repeats and are easily assembled. Plant genomes, particularly those of crops like wheat and maize, are full of [transposable elements](/knowledge/molecular-biology/transposable-element) and segmental duplications, making them extremely difficult to assemble. The solution is to use longer reads, which can span the repeats, or to use linked-read or Hi-C data to resolve the ambiguity.

Heterozygosity is a related challenge for diploid and polyploid organisms. When the two copies of a chromosome differ by single nucleotide polymorphisms or structural variants, the assembler sees two slightly different sequences for the same locus. In a de Bruijn graph, this creates bubbles—two alternative paths between the same nodes. The assembler must decide whether to merge the paths (producing a single consensus sequence) or keep them separate (producing two contigs, one for each haplotype). Most assemblers default to merging, which produces a haploid representation of a diploid genome. This is acceptable for many applications, but it loses information about heterozygosity.

### Choosing the Right Assembler

The choice of assembler has a major impact on the quality of the final assembly. For short-read data, the most popular assemblers are SPAdes, which uses a multi-k de Bruijn graph approach and is particularly good for bacterial genomes, and MEGAHIT, which is optimized for speed and memory efficiency. For large genomes, ABySS and SOAPdenovo2 are also used, though they are less actively maintained.

For long-read data, the choice depends on the read type. For PacBio HiFi reads, HiFiASM is the assembler of choice, producing highly contiguous and accurate assemblies with minimal parameter tuning. For noisy long reads (raw PacBio or ONT), Canu and Flye are the most popular options. Canu uses an OLC approach with extensive error correction, while Flye uses a repeat graph approach that is particularly good at resolving complex repeats.

A common mistake is to use an assembler that is not designed for the data type. For example, using a de Bruijn graph assembler designed for short reads on long-read data will produce poor results, because the assembler will fragment the long reads into k-mers and lose the long-range information. Conversely, using an OLC assembler on short-read data will be computationally intractable, because the O(n²) overlap detection cannot handle hundreds of millions of reads.

### Computational Resources and Time

Genome assembly is computationally intensive. A typical mammalian genome assembly with short reads requires 100–500 gigabytes of RAM and several days of compute time. Long-read assembly requires less RAM but more CPU time, particularly for the error correction and consensus steps. HiFi assembly is the most efficient, requiring only a few hours and modest resources for a mammalian genome.

Beginners often underestimate the computational requirements and attempt to run assemblies on a laptop. This is rarely successful for genomes larger than a few megabases. Cloud computing or a university cluster is recommended for any genome larger than a bacterial genome. It is also important to allocate time for the iterative nature of assembly: the first assembly attempt will likely reveal problems that require adjusting parameters, adding more data, or trying a different assembler.

Another practical consideration is coverage. The [Sequencing Coverage](/knowledge/molecular-biology/sequencing-coverage) required for assembly depends on the technology. For short reads, 50–100× coverage is recommended for de novo assembly. For PacBio HiFi, 30–50× coverage is typically sufficient. For noisy long reads, 50–100× coverage may be needed to achieve good error correction. Insufficient coverage is a common cause of fragmented assemblies, and adding more data is often the most effective way to improve assembly quality.

## Frequently Asked Questions

### What is the difference between genome sequencing and genome assembly?

Genome sequencing is the experimental process of determining the [nucleotide sequence](/knowledge/molecular-biology/nucleotide-sequence) of DNA fragments using a sequencing instrument. It produces reads—short or long sequences derived from individual DNA molecules. Genome assembly is the computational process of reconstructing the original genome sequence from these reads. Sequencing generates the raw data; assembly transforms that data into a genome. Sequencing is a laboratory procedure; assembly is a bioinformatics procedure.

### Why are long reads better for genome assembly?

Long reads are better for genome assembly because they can span repetitive elements. When a repeat is longer than the read length, the assembler cannot determine which copy of the repeat connects to which flanking sequence, creating ambiguity in the assembly graph. Long reads of 10–100 kilobases can span most repeats, including Alu elements, LINE-1 elements, and many segmental duplications, providing unambiguous connections between unique flanking regions. This dramatically improves assembly contiguity, as measured by N50, and reduces the number of gaps in the final assembly.

### What is N50 in genome assembly?

N50 is a contiguity metric that describes the length distribution of contigs or scaffolds in an assembly. To compute N50, sort the contigs by length from longest to shortest, then find the length of the contig at which the cumulative length reaches 50% of the total assembly length. Half of the assembled bases are in contigs of length N50 or longer. A higher N50 indicates a more contiguous assembly. L50 is the number of contigs needed to reach 50% of the assembly length; a lower L50 indicates a more contiguous assembly.

### What is a de Bruijn graph in genome assembly?

A de Bruijn graph is a data structure used by many short-read assemblers. The reads are decomposed into overlapping k-mers—substrings of length k. Each distinct k-mer becomes a node in the graph, and an edge connects two k-mers if they overlap by k−1 bases. The genome sequence corresponds to a path through the graph. The de Bruijn graph compresses the data by storing only the distinct k-mers rather than all reads, making it scalable to the enormous datasets produced by short-read sequencers. The main challenge is resolving branches in the graph caused by repeats and sequencing errors.

### How do I choose between short-read and long-read sequencing for assembly?

The choice depends on the genome size, the repeat content, the available budget, and the desired assembly quality. For small genomes with few repeats (e.g., bacterial genomes), short-read sequencing is sufficient and cost-effective. For large genomes with substantial repeat content (e.g., plant and vertebrate genomes), long-read sequencing is strongly recommended. PacBio HiFi reads offer the best combination of read length and accuracy and are the current gold standard for de novo assembly. If budget is limited, a hybrid approach—a small amount of long-read data to scaffold a larger short-read assembly—can be a cost-effective compromise.

### What is scaffolding in genome assembly?

Scaffolding is the process of ordering and orienting contigs into longer sequences called scaffolds. Contigs are contiguous sequences that are internally consistent, but their relative order and orientation along the chromosome are unknown. Scaffolding uses additional information—such as paired-end read distances, long-read alignments, or Hi-C contact frequencies—to determine the correct order and orientation of the contigs. The resulting scaffolds contain gaps (represented as Ns) where the sequence between contigs is unknown. Scaffolding is distinct from assembly, which produces the contigs themselves.

### What is BUSCO and why is it used?

BUSCO (Benchmarking Universal Single-Copy Orthologs) is a tool for assessing the completeness of a genome assembly. It uses a set of genes that are expected to be present as single copies in the target genome, based on ortholog databases for the appropriate taxonomic group. The assembled genome is searched for these genes, and the proportion that are found complete, fragmented, or missing is reported. A high-quality assembly should have >95% complete BUSCOs. BUSCO is used because contiguity metrics like N50 do not indicate whether the assembly contains all of the genome. A genome could have a high N50 but still be missing entire genes or chromosomes.

### What are common mistakes in genome assembly?

Common mistakes include: using an assembler that is not designed for the data type (e.g., a short-read assembler on long-read data); ignoring coverage bias, which can cause under-assembly of low-coverage regions; using an inappropriate k-mer size for de Bruijn graph assembly; overlooking the impact of repeats and heterozygosity on assembly quality; skipping quality control of the input reads; and underestimating the computational resources required. Another common mistake is failing to assess assembly quality with BUSCO and read-mapping metrics, leading to the publication of a low-quality assembly.

## Key Takeaways

- Genome assembly reconstructs a genome from sequencing reads, and the choice of sequencing technology (short-read vs. long-read) is the single most important determinant of assembly quality.
- Overlap-layout-consensus (OLC) is the preferred algorithm for long reads, while de Bruijn graphs are the standard for short reads; the choice of algorithm should match the data type.
- Preprocessing—read trimming, adapter removal, and error correction—is essential for assembly quality and should not be skipped.
- Scaffolding with paired-end, long-read, or Hi-C data orders and orients contigs, and is necessary for chromosome-level assemblies.
- Assembly quality must be assessed with multiple metrics: N50 for contiguity, BUSCO for completeness, and read-mapping for correctness.
- Hybrid assembly approaches, combining short and long reads, can produce high-quality assemblies at reduced cost.
- Repeats and heterozygosity are the fundamental biological challenges of assembly; longer reads are the most effective solution.

## Further Reading

- Richards S. *Arthropod Genome Sequencing and Assembly Strategies*. Methods in [molecular biology](/blog/careers/molecular-biology) (Clifton, N.J.). 2019. [PubMed 30414106](https://doi.org/10.1007/978-1-4939-8775-7_1)
- Li C et al. *Genome Sequencing and Assembly by Long Reads in Plants*. Genes. 2017. [PubMed 29283420](https://doi.org/10.3390/genes9010006)
- Gao Z et al. *Beef Cattle Genome Project: Advances in Genome Sequencing, Assembly, and Functional Genes Discovery*. International journal of molecular sciences. 2024. [PubMed 39000250](https://doi.org/10.3390/ijms25137147)
- Li FW, Harkess A. *A guide to sequence your favorite plant genomes*. Applications in plant sciences. 2018. [PubMed 29732260](https://doi.org/10.1002/aps3.1030)
- Gladman N et al. *Era of gapless plant genomes: innovations in sequencing and mapping technologies revolutionize genomics and breeding*. Current opinion in biotechnology. 2023. [PubMed 36640454](https://doi.org/10.1016/j.copbio.2022.102886)
- Dvorianinova EM, Dmitriev AA, Melnikova NV. *Fusarium Genome Sequencing and Assembly*. Methods in [molecular biology](/blog/careers/molecular-biology) (Clifton, N.J.). 2025. [PubMed 40736899](https://doi.org/10.1007/978-1-0716-4702-8_10)

## Related Topics

- [Genome Assembly and Annotation](/knowledge/molecular-biology/genome-assembly-and-annotation)
- [Bisulfite Sequencing](/knowledge/molecular-biology/bisulfite-sequencing)
- [ATAC Sequencing](/knowledge/molecular-biology/atac-sequencing)
- [CHIP Sequencing](/knowledge/molecular-biology/chip-sequencing)

## Related Clinical & Scientific Guides

* [MAPK Pathway: Mechanism, Function, and Clinical Relevance](/knowledge/molecular-biology/mapk-pathway)
* [Mammalian Cell Culture Bioreactors: A Practical Guide](/knowledge/molecular-biology/mammalian-cell-culture-bioreactor)
* [Nucleotide Formation: Biosynthesis and Assembly of DNA/RNA Building Blocks](/knowledge/molecular-biology/nucleotide-formation)