Chemistry · Intermediate

Consecutive reactions intermediate

Written by SignalsLab

Early edition: these lessons are being reviewed.

Content

Summary

In consecutive reactions A → B → C, the intermediate B is formed by the first step and consumed by the second, so its concentration rises, reaches a maximum, then falls. The timing of that maximum and its height depend on the ratio of the two rate constants.

Intuition

Picture water flowing from an upper tank (A) through a pipe into a middle tank (B), which drains into a lower tank (C). At first the middle tank is empty, so little drains out and its level rises. As the upper tank empties, inflow shrinks while outflow grows with the level in B. Eventually outflow beats inflow and B falls. If the outlet of B is much wider than the inlet (k2 >> k1), B never accumulates and stays small and nearly steady. If the inlet is wider (k1 >> k2), B builds up almost fully before slowly converting to C. The slower step is the bottleneck that controls how fast C appears.

Key equations

d[A]dt=−k1[A]
(1)

A decays by first-order kinetics.

d[B]dt=k1[A]−k2[B]
(2)

B is made from A and lost to C.

[B]=k1[A]0k2−k1(e−k1t−e−k2t)
(3)

Concentration of the intermediate over time (k1 ≠ k2).

tmax=ln⁡(k2/k1)k2−k1
(4)

Time at which B is at its maximum.

[C]=[A]0−[A]−[B]
(5)

Mass balance gives the product.

Derivation

  1. Solve the first step: [A]=[A]0 e^{-k1 t}.
  2. Substitute into d[B]/dt = k1[A]0 e^{-k1 t} - k2[B], a linear first-order ODE.
  3. Use the integrating factor e^{k2 t}: d([B]e^{k2 t})/dt = k1[A]0 e^{(k2-k1)t}.
  4. Integrate from 0 with [B]=0 at t=0: [B]e^{k2 t} = k1[A]0 (e^{(k2-k1)t}-1)/(k2-k1).
  5. Multiply by e^{-k2 t} to get [B]=k1[A]0(e^{-k1 t}-e^{-k2 t})/(k2-k1).
  6. Set d[B]/dt=0, so k1[A]=k2[B]; this gives k1 e^{-k1 t}=k2 e^{-k2 t}, hence t_max=ln(k2/k1)/(k2-k1).
  7. Find [C] from conservation: [C]=[A]0-[A]-[B].

Worked example

Problem

For A → B → C with k1 = 0.10 s^-1 and k2 = 0.40 s^-1, and [A]0 = 1.00 M, find t_max and [B] at t_max.

  1. t_max = ln(0.40/0.10)/(0.40-0.10) = ln4/0.30 = 1.386/0.30 = 4.62 s.
  2. e^{-k1 t} = e^{-0.462} = 0.630.
  3. e^{-k2 t} = e^{-1.848} = 0.158.
  4. Prefactor: k1[A]0/(k2-k1) = 0.10/0.30 = 0.333 M.
  5. [B]max = 0.333 × (0.630 - 0.158) = 0.333 × 0.472 = 0.157 M.

Answer t_max ≈ 4.6 s and [B]max ≈ 0.16 M

Common mistakes

  • Assuming the intermediate keeps rising until A is gone; B peaks while A is still present.
  • Using the formula when k1 = k2, where it is undefined; the limit is [B]=k[A]0 t e^{-kt}.
  • Thinking the faster step controls the overall rate of C formation; the slower step does.
  • Applying the steady-state approximation when k2 is not much larger than k1.
  • Forgetting that [A]+[B]+[C] stays constant.

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


def simulate_consecutive(k1, k2, c0_a, t_max, dt=0.005):
    """
    Simulate A -> B -> C kinetics.
    d[A]/dt = -k1[A]
    d[B]/dt = k1[A] - k2[B]
    d[C]/dt = k2[B]
    Returns t, A, B, C arrays.
    """
    n = int(t_max / dt)
    t = np.linspace(0, t_max, n + 1)
    A = np.zeros(n + 1)
    B = np.zeros(n + 1)
    C = np.zeros(n + 1)
    
    A[0] = c0_a
    B[0] = 0.0
    C[0] = 0.0
    
    for i in range(n):
        t_curr = t[i]
        dt_curr = t[i+1] - t_curr
        
        dA = -k1 * A[i] * dt_curr
        dB = (k1 * A[i] - k2 * B[i]) * dt_curr
        dC = k2 * B[i] * dt_curr
        
        A[i+1] = A[i] + dA
        B[i+1] = B[i] + dB
        C[i+1] = C[i] + dC
        
        # Ensure non-negative
        A[i+1] = max(0, A[i+1])
        B[i+1] = max(0, B[i+1])
        C[i+1] = max(0, C[i+1])
        
    return t, A, B, C


# Parameters: Fast first step, slow second step ensures B peaks and decays
K1, K2 = 2.0, 0.5  # k1 > k2 ensures clear intermediate peak and eventual decay
C0_A = 1.0
T_MAX = 10.0
N_STEPS = 2000
TRACE = simulate_consecutive(K1, K2, C0_A, T_MAX, dt=T_MAX/N_STEPS)

# Precompute peak time for B for caption
# t_max_B = ln(k1/k2) / (k1 - k2)
if K1 != K2:
    T_PEAK_THEORY = np.log(K1 / K2) / (K1 - K2)
else:
    T_PEAK_THEORY = 1 / K1

class Main(Scene):
    def construct(self):
        self.camera.background_color = "#111111"
        
        TitleCard(self, "Consecutive Reactions", "A -> B -> C Kinetics")
        
        # Setup Plot
        plot = CurvePlot(
            lambda t: 0, 
            x_range=(0, T_MAX, 2), 
            y_range=(0, 1.0, 0.2), 
            x_label="Time (s)", 
            y_label="Concentration",
            x_length=8.0, 
            y_length=4.5,
            color=WHITE
        )
        plot.shift(LEFT * 0.5)
        
        # Draw axes first
        self.play(Create(plot.axes), FadeIn(plot.labels))
        
        # Prepare data points
        t_vals = TRACE[0]
        a_vals = TRACE[1]
        b_vals = TRACE[2]
        c_vals = TRACE[3]
        
        # Create line objects
        line_A = VMobject(color=C_MAIN)
        line_B = VMobject(color=C_ACCENT)
        line_C = VMobject(color=C_GOOD)
        
        # Initial empty lines
        line_A.set_points_as_corners([plot.axes.c2p(0,0), plot.axes.c2p(0,0)])
        line_B.set_points_as_corners([plot.axes.c2p(0,0), plot.axes.c2p(0,0)])
        line_C.set_points_as_corners([plot.axes.c2p(0,0), plot.axes.c2p(0,0)])
        
        self.add(line_A, line_B, line_C)
        
        # Labels
        label_A = Text("A", font_size=24, color=C_MAIN)
        label_B = Text("B", font_size=24, color=C_ACCENT)
        label_C = Text("C", font_size=24, color=C_GOOD)
        self.add(label_A, label_B, label_C)
        
        # Animation loop
        def update_lines(mob):
            t_curr = tracker.get_value()
            # Find index closest to current time
            idx = np.searchsorted(t_vals, t_curr)
            idx = min(idx, len(t_vals)-1)
            
            # Get points up to idx
            pts_a = [plot.axes.c2p(t_vals[i], a_vals[i]) for i in range(idx+1)]
            pts_b = [plot.axes.c2p(t_vals[i], b_vals[i]) for i in range(idx+1)]
            pts_c = [plot.axes.c2p(t_vals[i], c_vals[i]) for i in range(idx+1)]
            
            if len(pts_a) > 1:
                line_A.set_points_as_corners(pts_a)
            if len(pts_b) > 1:
                line_B.set_points_as_corners(pts_b)
            if len(pts_c) > 1:
                line_C.set_points_as_corners(pts_c)
                
            # Update label positions at the tip
            if len(pts_a) > 0:
                label_A.move_to(pts_a[-1]).shift(UP*0.2)
            if len(pts_b) > 0:
                label_B.move_to(pts_b[-1]).shift(UP*0.2)
            if len(pts_c) > 0:
                label_C.move_to(pts_c[-1]).shift(UP*0.2)

        tracker = ValueTracker(0)
        
        self.play(
            UpdateFromFunc(line_A, update_lines),
            UpdateFromFunc(line_B, update_lines),
            UpdateFromFunc(line_C, update_lines),
            run_time=10,
            rate_func=linear
        )
        
        # Highlight peak of B
        idx_peak = np.argmax(b_vals)
        t_peak_actual = t_vals[idx_peak]
        b_peak_actual = b_vals[idx_peak]
        
        dot_peak = Dot(plot.axes.c2p(t_peak_actual, b_peak_actual), color=C_BAD, radius=0.1)
        line_v_peak = DashedLine(
            start=plot.axes.c2p(t_peak_actual, 0),
            end=plot.axes.c2p(t_peak_actual, b_peak_actual),
            color=C_DIM
        )
        
        self.play(FadeIn(dot_peak), Create(line_v_peak), run_time=1.5)
        
        caption_text = f"Peak [B] at t \\approx {t_peak_actual:.2f} s. Intermediate accumulates then decays."
        StepCaption(self, caption_text)
        
        self.wait(2)


if __name__ == "__main__" and "--selftest" in sys.argv:
    t, A, B, C = TRACE
    
    # Check initial conditions
    assert abs(A[0] - C0_A) < 1e-6
    assert abs(B[0] - 0.0) < 1e-6
    assert abs(C[0] - 0.0) < 1e-6
    
    # Check conservation of mass
    total = A + B + C
    assert np.allclose(total, C0_A, atol=1e-4), f"Mass not conserved: {total[-1]}"
    
    # Check B starts at 0 and ends near 0 (since k2 > 0, B decays to 0 eventually)
    # With k1=2.0, k2=0.5, T_MAX=10.0, B should be very small at the end.
    assert B[-1] < 0.01, f"B did not decay to near zero: {B[-1]}"
    
    # Check C ends near C0_A
    assert abs(C[-1] - C0_A) < 0.05, f"C did not reach equilibrium: {C[-1]} vs {C0_A}"
    
    # Check peak existence
    assert np.max(B) > 0, "B should have a positive peak"
    
    # Check peak time is reasonable (between 0 and t_max)
    idx_peak = np.argmax(B)
    t_peak = t[idx_peak]
    assert 0 < t_peak < T_MAX, f"Peak time {t_peak} out of bounds"
    
    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.