Biotechnology · Introductory

Cell culture doubling time

Written by SignalsLab

Early edition: these lessons are being reviewed.

Content

Summary

Doubling time is the time it takes a growing cell population to double in number during exponential growth. It links cell counts at two times to a constant growth rate, letting us predict growth and compare cell lines or conditions.

Intuition

During exponential (log phase) growth, every cell divides at roughly the same average rate, so the more cells you have, the more new cells appear per hour. One cell becomes 2, then 4, 8, 16. The time for each doubling is constant, whether you go from 1,000 to 2,000 cells or from 1 million to 2 million. That constant is the doubling time. Because growth multiplies rather than adds, we use logarithms to solve for it. The calculation only applies in log phase, not in lag phase (cells adjusting) or plateau phase (nutrients run out or cells become confluent).

Key equations

N(t)=N02t/Td
(1)

Cell number after time t, starting from N_0, with doubling time T_d.

N(t)=N0ekt
(2)

Equivalent exponential form with specific growth rate k.

Td=tln⁡2ln⁡(N/N0)
(3)

Doubling time from two counts N_0 and N measured t apart.

Td=ln⁡2k≈0.693k
(4)

Relationship between doubling time and growth rate.

Derivation

  1. Start with exponential growth: N = N_0 2^(t/T_d), because the population doubles once every T_d.
  2. Divide both sides by N_0: N/N_0 = 2^(t/T_d).
  3. Take the natural log of both sides: ln(N/N_0) = (t/T_d) ln 2.
  4. Solve for T_d: T_d = t ln 2 / ln(N/N_0).
  5. Comparing with N = N_0 e^(kt) gives k = ln 2 / T_d, so T_d = 0.693/k.

Worked example

Problem

A culture has 2.0 x 10^5 cells at the start and 1.6 x 10^6 cells 24 hours later, still in log phase. What is the doubling time?

  1. Compute the fold increase: N/N_0 = 1.6e6 / 2.0e5 = 8.
  2. Number of doublings = log2(8) = 3.
  3. Doubling time = 24 h / 3 = 8 h.
  4. Check with the formula: T_d = 24 x 0.693 / ln 8 = 16.63 / 2.079 = 8.0 h.

Answer The doubling time is 8 hours (growth rate k about 0.087 per hour).

Common mistakes

  • Applying the formula across lag or plateau phases, which gives a wrong, inflated doubling time.
  • Using log base 10 with ln 2 (or mixing bases) in the same formula.
  • Using the difference N - N_0 instead of the ratio N/N_0.
  • Mixing time units, such as counts in hours but doubling time reported in days.
  • Using counts that include dead cells, rather than viable cell counts.

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

TD = 20.0   # doubling time in hours
N0 = 1000.0  # starting cells


def cells(t, n0=N0, td=TD):
    """Exponential growth N(t) = N0 * 2^(t/Td)."""
    return n0 * 2.0 ** (t / td)


def log2_cells(t):
    """log2 of cell count, computed from the formula."""
    return float(np.log2(cells(t)))


class Main(Scene):
    def construct(self):
        # Title
        TitleCard(self, "Cell culture doubling time", "Exponential growth")

        # Plot of cells (in thousands) over 80 h
        f = lambda t: cells(t) / 1000.0
        plot = CurvePlot(f, x_range=(0, 80, 20), y_range=(0, 16, 4),
                         x_label="t (h)", y_label="N (k)",
                         color=C_ACCENT, x_length=7.0, y_length=4.0)
        # keep the whole plot, including labels, inside the frame
        plot.move_to(ORIGIN).to_edge(LEFT, buff=1.0).shift(DOWN * 0.1)
        self.play(Create(plot.axes), Write(plot.labels))
        self.play(Create(plot.curve), run_time=3)

        # Doubling markers at multiples of Td
        dots = VGroup()
        notes = VGroup()
        for k in range(5):
            t = k * TD
            d = plot.dot_at(t, color=C_GOOD)
            dots.add(d)
            lab = Text(f"{int(f(t))}", font_size=24, color=C_GOOD)
            lab.next_to(d, UP + LEFT, buff=0.08)
            notes.add(lab)
        for d, lab in zip(dots, notes):
            self.play(FadeIn(d), FadeIn(lab), run_time=0.5)

        # Formula on the right
        eq = MathTex(r"N(t)=N_0\,2^{t/T_d}", font_size=40)
        eq.to_edge(RIGHT, buff=0.6).shift(UP * 1.2)
        par = Text("N0 = 1000, Td = 20 h", font_size=24, color=C_DIM)
        par.next_to(eq, DOWN, buff=0.3)
        self.play(Write(eq), FadeIn(par))
        self.wait(1)

        StepCaption(self, "Every Td hours the cell number doubles.")
        self.wait(1.5)


if __name__ == "__main__" and "--selftest" in sys.argv:
    assert abs(cells(0) - N0) < 1e-9
    assert abs(cells(TD) - 2 * N0) < 1e-9
    assert abs(cells(4 * TD) - 16 * N0) < 1e-6
    assert abs(log2_cells(3 * TD) - log2_cells(0) - 3) < 1e-9
    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.