Before you start
- Just curiosity, plus the idea that DNA is a sequence of four letters (A, T, G, C). New to that? See The biology a coder needs.
- Any term feels new? The Glossary explains everything in plain English.
Learning objectives
By the end of this lesson you will be able to: explain how massively parallel sequencing reads millions of DNA fragments at once, describe what a read is and how reads come out of an NGS run, and walk through the standard NGS workflow at a glance.
The leap that changed biology
To do almost anything in genomics, you first need to read the DNA, to turn a physical molecule into letters you can analyze on a computer. For decades that was slow and expensive: the old method (Sanger sequencing) read one short piece at a time. Sequencing the first human genome took over a decade and billions of dollars.
Next-generation sequencing (NGS) changed everything by doing the same job a different way.
Instead of reading one DNA fragment at a time, NGS reads millions of fragments in parallel, all at once. That single idea is why sequencing a human genome, which once took years and billions of dollars, is now fast and cheap: a high-throughput run reads a genome to high coverage in roughly a day, and at scale the sequencing reagents cost only a few hundred dollars per genome (library preparation, instrument time, and analysis add to the real total).
The core trick: massively parallel sequencing
You do not need the chemistry, just the shape of it. Here is what happens:
- The DNA is chopped into millions of small fragments.
- The fragments are spread across a small chip (a flow cell) and copied many times, so each forms a tiny bright spot.
- The machine then reads every spot at the same time, one letter per cycle: add a base, take a picture of which color lit up, repeat. The color tells you the letter (A, T, G, or C).
Because millions of spots are photographed together each cycle, the machine reads an enormous amount of DNA in parallel. The most common platform is Illumina, but the core idea is shared across modern sequencers.
What comes out: reads
The output is not one long genome. It is a giant pile of short sequences, one per fragment, called reads. Putting the genome back together (or comparing reads to a known reference) is the job of the analysis steps that follow in this track.
Decode the jargonRead and read length
A read is the sequence of one fragment as the machine saw it, for example GATTACAGGC.... The read length is how many letters long it is. Illumina produces "short reads" (commonly 100 to 150 letters). Other technologies produce "long reads" (thousands of letters), which are better for assembling tricky regions.
Decode the jargonPaired-end reads
Often each fragment is read from both ends, giving a pair of reads with a known gap between them. These paired-end reads make it much easier to figure out where a fragment belongs in the genome, especially across repetitive regions.
Decode the jargonCoverage (depth)
Because there are so many overlapping fragments, every position in the genome ends up being read many times over. "30x coverage" means each base was read about 30 times on average. More coverage means more confidence, which is crucial when you later decide whether a difference from the reference is a real variant or just a sequencing error.
The NGS workflow at a glance
Every DNA-sequencing experiment follows the same shape. The first three steps happen in the lab; the rest is the bioinformatics you'll learn in this track. Click any computational step to jump straight to its lesson.
One engine, many uses
NGS is a general-purpose DNA-reading machine, so the same technology powers many different experiments depending on what you feed in and how you analyze it:
- DNA sequencing: find differences (variants) between a sample and the reference genome. This is the focus of Track 2.
- RNA-seq: measure gene activity (the focus of Track 3).
- And more: ChIP-seq, ATAC-seq, single-cell, and others, all built on the same read-everything-in-parallel idea.
What's next in this track
Now that you have the picture, the rest of Track 2 walks the DNA workflow end to end, all in your browser: checking read quality with FastQC, trimming bad bases, aligning reads to a reference genome, wrangling the results with samtools, and finally calling variants to produce a VCF. By the end you'll have run a real mini variant-calling pipeline.