Biotechnology · Intermediate

Monod growth kinetics

Written by SignalsLab

Early edition: these lessons are being reviewed.

Content

Summary

Monod kinetics describes how the specific growth rate of microorganisms depends on the concentration of a single limiting nutrient. Growth rises almost linearly at low substrate and saturates at a maximum rate at high substrate, much like Michaelis-Menten enzyme kinetics. It is the basis for modelling batch cultures and chemostats.

Intuition

Imagine cells as workers who can only grow as fast as they are fed. When food is scarce, doubling the food nearly doubles growth. When food is abundant, the cells' internal machinery (transporters, enzymes, ribosomes) is already working flat out, so extra food does nothing. The curve therefore bends from a straight rise into a plateau. The constant Ks is the substrate concentration at which cells grow at half their maximum rate, so it measures how good the cells are at scavenging: a small Ks means high affinity. Because cells consume substrate as they grow, S falls over time, growth slows, and eventually stops when the nutrient runs out.

Key equations

μ=μmaxSKs+S
(1)

Specific growth rate as a function of limiting substrate concentration S.

dXdt=μX
(2)

Biomass increases in proportion to current biomass.

dSdt=−1YX/SμX
(3)

Substrate is consumed in proportion to growth, with yield coefficient Y (g biomass per g substrate).

μ=D⇒S∗=KsDμmax−D
(4)

Steady-state substrate in a chemostat with dilution rate D.

Derivation

  1. Observe empirically that μ rises with S and saturates at μmax.
  2. Assume growth is limited by one rate-controlling step that is saturable in S, as in enzyme binding: μ proportional to the fraction of sites occupied.
  3. Fraction occupied = S/(Ks+S), so μ=μmaxS/(Ks+S).
  4. Check limits: if S≪Ks, μ≈(μmax/Ks)S, first order; if S≫Ks, μ≈μmax, zero order; if S=Ks, μ=μmax/2.
  5. Couple to mass balances: dXdt=μX and dSdt=−1YμX.
  6. For a chemostat at steady state, dXdt=0 gives μ=D; solve the Monod expression for S to get S∗=KsDμmax−D.
  7. Washout occurs when D exceeds mu_max S_in/(Ks+S_in), since cells cannot grow fast enough to replace those leaving.

Worked example

Problem

A bacterium has μmax=0.8 per hour and Ks=20 mg/L. Find μ at S=5 mg/L, and the substrate concentration in a chemostat run at D=0.4 per hour.

  1. At S=5: μ=0.8×5/(20+5)=0.8×0.2=0.16 per hour.
  2. For the chemostat, μ=D=0.4 per hour.
  3. S* = Ks D/(mu_max - D) = 20 × 0.4/(0.8 - 0.4) = 8/0.4 = 20 mg/L.
  4. μ=0.8×20/40=0.4, which matches D.

Answer μ=0.16 per hour at 5 mg/L; chemostat steady-state S=20 mg/L (equal to Ks, because D=μmax/2).

Common mistakes

  • Confusing specific growth rate μ (per time) with biomass growth rate dXdt.
  • Thinking Ks is the substrate level for maximum growth; it gives half-maximum.
  • Using Monod when more than one nutrient, inhibition by substrate, or product inhibition matters.
  • Forgetting the yield coefficient when linking substrate consumption to biomass.
  • Setting D above mu_max and expecting a steady state; this leads to washout.
  • Mixing units of Ks (mass/volume) and S.

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

# Monod batch culture: mu = mu_max*S/(Ks+S), dX/dt = mu X, dS/dt = -mu X / Y
MU_MAX, KS, YIELD = 0.5, 2.0, 0.5
X0, S0 = 0.1, 10.0
DT, T_END = 0.05, 24.0


def simulate():
    """Fixed-step Euler simulation of batch growth; returns arrays t, X, S."""
    n = int(round(T_END / DT))
    t = np.zeros(n + 1)
    X = np.zeros(n + 1)
    S = np.zeros(n + 1)
    X[0], S[0] = X0, S0
    for k in range(n):
        s = max(S[k], 0.0)
        mu = MU_MAX * s / (KS + s)
        X[k + 1] = X[k] + DT * mu * X[k]
        S[k + 1] = max(S[k] - DT * mu * X[k] / YIELD, 0.0)
        t[k + 1] = t[k] + DT
    return t, X, S


def mu_of(s):
    """Monod specific growth rate."""
    return MU_MAX * s / (KS + s)


T, XS, SS = simulate()


class Main(Scene):
    def construct(self):
        TitleCard(self, "Monod growth kinetics", "batch culture simulation")
        # Left: mu(S) curve
        mu_plot = CurvePlot(mu_of, x_range=(0, 10, 2), y_range=(0, 0.6, 0.2),
                            x_label="S", y_label="mu", color=C_ACCENT,
                            x_length=5.0, y_length=3.4)
        mu_plot.to_edge(LEFT, buff=0.7).shift(UP * 0.2)
        eq = MathTex(r"\mu=\frac{\mu_{max}S}{K_s+S}", font_size=32)
        eq.next_to(mu_plot, DOWN, buff=0.3)
        self.play(Create(mu_plot.axes), Write(mu_plot.labels))
        self.play(Create(mu_plot.curve), Write(eq))
        StepCaption(self, "Growth rate saturates at high substrate")

        # Right: X(t), S(t) from simulation
        ax = Axes(x_range=[0, 24, 6], y_range=[0, 10, 5], x_length=5.5, y_length=3.4,
                  axis_config={"color": C_DIM, "include_tip": False})
        ax.to_edge(RIGHT, buff=0.7).shift(UP * 0.2)
        xl = Text("t (h)", font_size=24).next_to(ax, DOWN, buff=0.15)
        self.play(Create(ax), Write(xl))
        idx = list(range(0, len(T), 4))
        xc = ax.plot_line_graph(T[idx], XS[idx] * 1.0, add_vertex_dots=False,
                                line_color=C_GOOD, stroke_width=4)
        sc = ax.plot_line_graph(T[idx], SS[idx], add_vertex_dots=False,
                                line_color=C_BAD, stroke_width=4)
        lx = Text("biomass X", font_size=24, color=C_GOOD).next_to(ax, UP, buff=0.1).shift(LEFT * 1.2)
        ls = Text("substrate S", font_size=24, color=C_BAD).next_to(ax, UP, buff=0.1).shift(RIGHT * 1.2)
        self.play(Create(sc), Create(xc), FadeIn(lx), FadeIn(ls), run_time=3)
        StepCaption(self, "Biomass grows until substrate runs out")
        self.wait(1)
        StepCaption(self, "Monod: growth rate follows substrate, then saturates")
        self.wait(1)


if __name__ == "__main__" and "--selftest" in sys.argv:
    assert abs(XS[0] - X0) < 1e-12 and abs(SS[0] - S0) < 1e-12
    assert abs(mu_of(KS) - MU_MAX / 2) < 1e-12
    assert np.all(np.diff(XS) >= -1e-12)
    assert np.all(np.diff(SS) <= 1e-12)
    # mass balance: X + Y*S conserved approximately
    assert abs((XS[-1] + YIELD * SS[-1]) - (X0 + YIELD * S0)) < 0.05
    assert SS[-1] < 0.1
    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.