Biotechnology · Advanced

Sequencing by synthesis

Written by SignalsLab

Early edition: these lessons are being reviewed.

Content

Summary

Sequencing by synthesis (SBS), as used in Illumina platforms, reads a DNA template by watching a polymerase add reversibly terminated, fluorescently labeled nucleotides one base per cycle. Clusters of identical template copies on a flow cell are imaged each cycle, and the color sequence is converted into base calls with quality scores. Read length equals the number of cycles, and errors accumulate through phasing and prephasing.

Intuition

Imagine thousands of identical copies of a DNA fragment anchored together in a tiny cluster. You let the polymerase extend each copy by exactly one base, then photograph the cluster. The color of the glow tells you which base was just added. Because every nucleotide carries a blocker, the polymerase must stop after one step; you then cleave off the dye and the blocker, and repeat. Reading millions of clusters in parallel gives massive throughput. The catch is that copies in a cluster slowly fall out of step, so the signal blurs as cycles go on, and quality drops toward the end of the read.

Key equations

L=Ncycles
(1)

Read length equals the number of incorporation-imaging cycles performed.

Q=−10log10⁡(Pe)
(2)

Phred quality score Q relates to the probability P_e that a base call is wrong; Q30 means 1 error in 1000.

In(t)≈(1−p−q)In0+pIn+10+qIn−10
(3)

Simplified phasing model: a fraction p of strands lags behind (failed extension) and a fraction q runs ahead (incomplete blocking), contaminating the signal.

Coverage=N⋅LG
(4)

Mean depth from N reads of length L over a genome of size G.

Derivation

  1. Start with a template strand hybridized to a primer on the flow cell, amplified by bridge amplification into a clonal cluster of about 1000 identical copies.
  2. Add polymerase and four nucleotides, each with a 3'-O-blocking group and a distinct fluorophore. Only one nucleotide complementary to the next template base is incorporated per strand, then synthesis halts.
  3. Wash away unincorporated nucleotides and image the flow cell. The emission color for each cluster identifies the base added at that cycle.
  4. Cleave the fluorophore and the 3' blocker chemically, regenerating a free 3'-OH.
  5. Repeat for N cycles. The sequence of colors per cluster is the read of length N.
  6. Per-cycle failure probability p of extension means the fraction of strands in step after n cycles is about (1-p)^n, so signal purity falls with n.
  7. Base callers compute the ratio of the called-channel intensity to total, convert to error probability, and report Phred scores.

Worked example

Problem

A cluster has a per-cycle phasing rate of 0.2% (strands that fail to extend). Estimate the fraction of strands still in step at cycle 150, and the coverage if 600 million reads of 150 bases are generated for a 3.1 Gb human genome.

  1. In-step fraction = (1 - 0.002)^150.
  2. ln(0.998) ≈ -0.002002, times 150 = -0.3003.
  3. e^-0.3003 ≈ 0.741, so about 74% of strands are in step.
  4. Coverage = N·L/G = (600×10^6 × 150)/(3.1×10^9).
  5. Numerator = 9.0×10^10 bases; divided by 3.1×10^9 ≈ 29.

Answer About 74% of strands remain in phase at cycle 150, and mean coverage is about 29×.

Common mistakes

  • Thinking the polymerase adds many bases per cycle; the reversible terminator limits it to one.
  • Confusing SBS with Sanger sequencing: Sanger uses irreversible terminators and size separation, not cyclic imaging.
  • Assuming quality is uniform along the read; it declines with cycle number due to phasing and prephasing.
  • Forgetting that cluster signal is the average of many copies, not a single molecule.
  • Mixing up read length with insert size or coverage.

Animation

Animation coming soon

The animated version of this lesson is being prepared for the web. In the Signals AI app, lessons are drawn step by step.

Code

scene.py(72 lines)
import sys
from manim import *
from blocks import *


def bridge_amplification(n_clusters_start=1, cycles=4):
    """Simulate bridge amplification: each cycle doubles strands (forward + reverse)."""
    fwd, rev = 1, 0  # one seeded template strand, attached forward
    trace = [{"cycle": 0, "fwd": fwd, "rev": rev, "total": fwd + rev}]
    for c in range(1, cycles + 1):
        # each forward strand bridges and copies into a reverse strand;
        # each reverse strand bridges and copies into a forward strand
        new_rev, new_fwd = fwd, rev
        fwd += new_fwd
        rev += new_rev
        trace.append({"cycle": c, "fwd": fwd, "rev": rev, "total": fwd + rev})
    return trace


def sbs_read(template):
    """Sequencing by synthesis: record the base added each cycle (complement)."""
    comp = {"A": "T", "T": "A", "G": "C", "C": "G"}
    reads = []
    for i, b in enumerate(template):
        reads.append({"cycle": i + 1, "added": comp[b]})
    return reads


TRACE = bridge_amplification(1, 4)
TEMPLATE = "ACGTTG"
READS = sbs_read(TEMPLATE)


class Main(Scene):
    def construct(self):
        self.camera.background_color = "#14161c"
        TitleCard(self, "Sequencing by synthesis", "Illumina bridge amplification")

        # Part 1: amplification trace as bars of strand counts
        totals = [s["total"] for s in TRACE]
        bars = ArrayBars(totals, max_width=6.0, max_height=3.0)
        bars.move_to(UP * 0.2)
        head = Text("Strands per cluster after each cycle", font_size=26, color=C_DIM)
        head.next_to(bars, UP, buff=0.4)
        self.play(FadeIn(bars), FadeIn(head))
        for s in TRACE[1:]:
            StepCaption(self, f"Cycle {s['cycle']}: {s['fwd']} forward + {s['rev']} reverse")
            self.play(bars.mark([s["cycle"]], C_GOOD), run_time=0.5)
        self.play(FadeOut(bars), FadeOut(head))

        # Part 2: reading the template base by base
        StepCaption(self, "Sequencing: one labelled base is added per cycle")
        tmpl = VGroup(*[Text(b, font_size=36, color=C_MAIN) for b in TEMPLATE])
        tmpl.arrange(RIGHT, buff=0.5).move_to(UP * 0.5)
        added = VGroup()
        for i, t in enumerate(tmpl):
            r = READS[i]
            a = Text(r["added"], font_size=36, color=C_ACCENT).next_to(t, DOWN, buff=0.6)
            added.add(a)
        self.play(FadeIn(tmpl))
        for a in added:
            self.play(FadeIn(a, shift=0.3 * UP), run_time=0.5)
        StepCaption(self, "Each cluster flashes its base color, giving the read")
        self.wait(1)


if __name__ == "__main__" and "--selftest" in sys.argv:
    assert TRACE[0]["total"] == 1
    assert [s["total"] for s in TRACE] == [1, 2, 4, 8, 16]
    assert all(s["fwd"] + s["rev"] == s["total"] for s in TRACE)
    assert "".join(r["added"] for r in READS) == "TGCAAC"
    print("selftest ok")

The Manim scene code that draws this lesson's animation in the Signals AI app (Python, Manim Community).

ccBYNC© 2026 SignalsLab. Lesson text shared as is under CC BY-NC 4.0.