Biotechnology · Intermediate

ELISA four-parameter standard curve

Written by SignalsLab

Early edition: these lessons are being reviewed.

Content

Summary

ELISA readouts (optical density) are related to analyte concentration by a sigmoidal dose-response curve, best described by the four-parameter logistic (4PL) model. We fit the 4PL to known standards, then invert it to calculate the concentration of unknown samples from their measured absorbance.

Intuition

At very low antigen concentration the signal sits at a floor (background). At very high concentration the binding sites saturate and the signal flattens at a ceiling. In between, signal rises steeply and roughly linearly on a log-concentration axis. A symmetric S-shaped curve on log scale captures this with four numbers: the bottom plateau, the top plateau, the midpoint concentration (EC50) where the signal is halfway, and a slope factor describing how sharply the curve rises. Once those four numbers are fitted to standards, we can read the curve backwards: measure an absorbance, get a concentration.

Key equations

y=d+a−d1+(xc)b
(1)

4PL model: y is OD, x is concentration; a is the response at zero concentration (bottom), d is the response at infinite concentration (top), c is the EC50 (inflection point), b is the Hill slope.

x=c(a−yy−d)1/b
(2)

Inverse 4PL used to back-calculate unknown concentration from measured OD y (valid for y strictly between a and d).

mina,b,c,d⁡∑i(yi−f(xi;a,b,c,d))2
(3)

Nonlinear least squares used to fit parameters to the standards (often with weighting).

Derivation

  1. Start with a response that moves from a (at x=0) to d (at x large). Define the fraction of the span: (y-d)/(a-d).
  2. Model this fraction as a binding-like term: 1/(1+(x/c)^b). At x=0 it equals 1 (y=a); as x grows it tends to 0 (y=d); at x=c it equals 1/2.
  3. Hence y = d + (a-d)/(1+(x/c)^b).
  4. To invert, subtract d: y-d = (a-d)/(1+(x/c)^b).
  5. Rearrange: 1+(x/c)^b = (a-d)/(y-d).
  6. So (x/c)^b = (a-d)/(y-d) - 1 = (a-y)/(y-d).
  7. Take the 1/b power: x = c((a-y)/(y-d))^(1/b).

Worked example

Problem

A 4PL fit to standards gives a = 0.05, d = 2.05, c = 100 pg/mL, b = 1.5. A sample has OD = 1.05. Find its concentration.

  1. Compute a - y = 0.05 - 1.05 = -1.00.
  2. Compute y - d = 1.05 - 2.05 = -1.00.
  3. Ratio = (-1.00)/(-1.00) = 1.
  4. Raise to 1/b: 1^(1/1.5) = 1.
  5. x = c × 1 = 100 pg/mL.
  6. Check: 1.05 is the midpoint of 0.05 and 2.05, which is exactly the EC50 response, so the answer makes sense.

Answer 100 pg/mL (the EC50). Multiply by any dilution factor to get the original sample concentration.

Common mistakes

  • Fitting a straight line to the whole range instead of the sigmoid, causing large errors near the plateaus.
  • Reporting concentrations for ODs outside the range between a and d, or in the flat tails, where the inverse is extremely imprecise or undefined.
  • Forgetting to multiply by the sample dilution factor.
  • Mixing up a and d: here a is the zero-concentration response, which may be the lower or upper asymptote depending on assay format (competitive ELISAs decline).
  • Not subtracting blank wells or using unweighted fitting when variance rises with signal.

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

# 4PL parameters: A = OD at zero dose, D = OD at saturation, C = EC50, B = slope
A, B, C, D = 0.05, 1.3, 40.0, 2.4


def four_pl(x):
    """Four-parameter logistic: OD as a function of concentration."""
    return D + (A - D) / (1.0 + (x / C) ** B)


def inverse_4pl(y):
    """Concentration from OD by inverting the 4PL."""
    return C * ((A - D) / (y - D) - 1.0) ** (1.0 / B)


# standard concentrations (ng/mL) and computed ODs
STD_X = np.array([1, 3, 10, 30, 100, 300, 1000], dtype=float)
STD_Y = four_pl(STD_X)
UNKNOWN_OD = 1.0
UNKNOWN_X = inverse_4pl(UNKNOWN_OD)


class Main(Scene):
    def construct(self):
        self.camera.background_color = "#14161c"
        TitleCard(self, "ELISA standard curve", "Four-parameter logistic fit")

        # plot in log10 concentration
        lf = lambda u: float(four_pl(10 ** u))
        plot = CurvePlot(lf, x_range=(0, 3, 1), y_range=(0, 2.5, 0.5),
                         x_label="log10 conc", y_label="OD",
                         x_length=7.0, y_length=4.0, color=C_MAIN)
        plot.move_to([-2.2, -0.2, 0])
        self.play(Create(plot.axes), FadeIn(plot.labels))

        # standards as dots
        dots = VGroup(*[Dot(plot.axes.c2p(np.log10(x), y), color=C_ACCENT, radius=0.09)
                        for x, y in zip(STD_X, STD_Y)])
        self.play(FadeIn(dots, lag_ratio=0.2), run_time=1.5)
        self.play(Create(plot.curve), run_time=2)

        # equation
        eq = MathTex(r"y=D+\frac{A-D}{1+(x/C)^B}", font_size=32)
        eq.to_edge(RIGHT, buff=0.5).shift(UP * 1.5)
        self.play(Write(eq))
        info = Text("A=0.05 D=2.4\nC=40 B=1.3", font_size=24, color=C_DIM)
        info.next_to(eq, DOWN, buff=0.4)
        self.play(FadeIn(info))

        # read unknown sample by inverting the curve
        ux = np.log10(UNKNOWN_X)
        hline = DashedLine(plot.axes.c2p(0, UNKNOWN_OD), plot.axes.c2p(ux, UNKNOWN_OD), color=C_GOOD)
        vline = DashedLine(plot.axes.c2p(ux, UNKNOWN_OD), plot.axes.c2p(ux, 0), color=C_GOOD)
        self.play(Create(hline))
        self.play(Create(vline))
        res = Text(f"OD 1.0 -> {UNKNOWN_X:.0f} ng/mL", font_size=26, color=C_GOOD)
        res.next_to(info, DOWN, buff=0.4)
        res.to_edge(RIGHT, buff=0.3)
        self.play(FadeIn(res))
        StepCaption(self, "Fit standards, then invert the curve to read unknowns.")
        self.wait(1.5)


if __name__ == "__main__" and "--selftest" in sys.argv:
    assert abs(four_pl(1e-9) - A) < 1e-6
    assert abs(four_pl(1e12) - D) < 1e-3
    assert abs(four_pl(C) - (A + D) / 2) < 1e-9
    assert np.all(np.diff(STD_Y) > 0)
    assert abs(four_pl(UNKNOWN_X) - UNKNOWN_OD) < 1e-9
    assert STD_X[0] < UNKNOWN_X < STD_X[-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.