Biotechnology · Intermediate

qPCR threshold cycle

Written by SignalsLab

Early edition: these lessons are being reviewed.

Content

Summary

In quantitative PCR, fluorescence rises as DNA is amplified. The threshold cycle (Ct) is the cycle at which fluorescence first crosses a fixed threshold in the exponential phase. Because each cycle roughly doubles the product, a lower Ct means more starting template, and Ct is linearly related to the log of the starting amount.

Intuition

Imagine a pond where lily pads double in number each day. If you start with many pads, the pond reaches a set coverage early; if you start with few, it takes more days. Ct is the 'day' you reach the set coverage. In qPCR the threshold is set above background noise but within the exponential phase, where amplification is regular. Each cycle difference of about 3.3 corresponds to a tenfold difference in starting template when efficiency is 100%, because 2^3.32 is about 10.

Key equations

NC=N0(1+E)C
(1)

Amount of product after C cycles, starting from N_0 copies with efficiency E (E = 1 means perfect doubling).

NCt=N0(1+E)Ct
(2)

At the threshold cycle the product equals the fixed threshold quantity N_T.

Ct=log⁡NT−log⁡N0log⁡(1+E)
(3)

Ct falls linearly as log of starting template rises.

E=10−1/slope−1
(4)

Efficiency obtained from the slope of the standard curve of Ct versus log10 of starting quantity.

fold change=2−ΔΔCt
(5)

Relative expression by the Livak method, assuming about 100% efficiency for target and reference.

Derivation

  1. Start with exponential growth: after C cycles, N_C = N_0(1+E)^C.
  2. Define the threshold fluorescence as corresponding to a fixed amount N_T, reached at cycle Ct: N_T = N_0(1+E)^Ct.
  3. Take logs of both sides: log N_T = log N_0 + Ct log(1+E).
  4. Solve: Ct = (log N_T - log N_0)/log(1+E).
  5. So plotting Ct against log10 N_0 gives a straight line with slope = -1/log10(1+E).
  6. Rearranging gives E = 10^(-1/slope) - 1. With E = 1, slope = -1/log10(2) = -3.32.
  7. For two samples with the same N_T and E: N_0,A/N_0,B = (1+E)^(Ct,B - Ct,A). With E = 1 this is 2^(ΔCt).

Worked example

Problem

A standard curve gives Ct = -3.45 log10(N_0) + 38. (a) Find the efficiency. (b) A sample has Ct = 24.5. Estimate its starting copy number.

  1. Slope = -3.45, so E = 10^(-1/-3.45) - 1 = 10^(0.2899) - 1.
  2. 10^0.2899 ≈ 1.949, so E ≈ 0.949, i.e. about 95% efficiency.
  3. For the sample: 24.5 = -3.45 log10(N_0) + 38.
  4. So -3.45 log10(N_0) = -13.5, giving log10(N_0) = 3.913.
  5. N_0 = 10^3.913 ≈ 8.2 × 10^3 copies.

Answer Efficiency about 95%; the sample contains roughly 8,000 starting copies.

Common mistakes

  • Thinking a higher Ct means more template; it means less.
  • Setting the threshold in the plateau or in the noise rather than the exponential phase.
  • Assuming 100% efficiency without checking the standard curve slope (acceptable range about -3.1 to -3.6).
  • Comparing Ct values between runs with different thresholds or baselines.
  • Treating a Ct difference of 1 as a tenfold change; it is about twofold, while 3.3 cycles is tenfold.
  • Ignoring no-template controls, where late Ct values may reflect primer dimers or contamination.

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(66 lines)
import sys
import numpy as np
from manim import *
from blocks import *

# Model: F(n) = F0 * (1+E)^n, capped by a logistic plateau
E = 0.95
FMAX = 1.0
THRESH = 0.2


def fluor(n, f0):
    """Fluorescence with exponential growth saturating at FMAX."""
    g = f0 * (1 + E) ** n
    return FMAX * g / (FMAX + g)


def ct_value(f0):
    """Cycle where fluorescence crosses THRESH (analytic inversion)."""
    g = THRESH * FMAX / (FMAX - THRESH)
    return np.log(g / f0) / np.log(1 + E)


F0S = [1e-3, 1e-4, 1e-5]
COLS = [C_GOOD, C_ACCENT, C_BAD]
CTS = [ct_value(f) for f in F0S]


class Main(Scene):
    def construct(self):
        TitleCard(self, "qPCR threshold cycle", "Ct shifts with starting amount")
        # axes
        plot = CurvePlot(lambda x: fluor(x, F0S[0]), x_range=(0, 40, 10),
                         y_range=(0, 1, 0.5), x_label="cycle", y_label="signal",
                         color=COLS[0], x_length=8, y_length=4.2)
        plot.move_to(LEFT * 1.5 + DOWN * 0.1)
        self.play(Create(plot.axes), Write(plot.labels))
        ax = plot.axes
        # threshold line
        th = DashedLine(ax.c2p(0, THRESH), ax.c2p(40, THRESH), color=WHITE)
        thl = Text("threshold", font_size=24).next_to(th, UP, buff=0.05).align_to(th, RIGHT)
        self.play(Create(th), FadeIn(thl))
        # three curves with Ct markers
        legend = VGroup()
        for f0, c, ct in zip(F0S, COLS, CTS):
            curve = ax.plot(lambda x, f0=f0: fluor(x, f0), x_range=[0, 40],
                            color=c, use_smoothing=False)
            dot = Dot(ax.c2p(ct, THRESH), color=c)
            drop = DashedLine(ax.c2p(ct, THRESH), ax.c2p(ct, 0), color=c)
            self.play(Create(curve), run_time=1.5)
            self.play(FadeIn(dot), Create(drop), run_time=0.6)
            legend.add(Text(f"Ct = {ct:.1f}", font_size=26, color=c))
        legend.arrange(DOWN, aligned_edge=LEFT, buff=0.3).to_edge(RIGHT, buff=0.6).shift(UP * 0.5)
        self.play(FadeIn(legend))
        StepCaption(self, "10x less template shifts Ct by about 3.5 cycles")
        self.wait(1.5)


if __name__ == "__main__" and "--selftest" in sys.argv:
    for f0, ct in zip(F0S, CTS):
        assert abs(fluor(ct, f0) - THRESH) < 1e-9
    assert CTS[0] < CTS[1] < CTS[2]
    d = CTS[1] - CTS[0]
    assert abs(d - np.log2(10) / np.log2(1 + E)) < 1e-9 or abs(d - np.log(10) / np.log(1 + E)) < 1e-9
    assert fluor(0, F0S[0]) < 0.01
    print("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.