Biotechnology · Intermediate

Plasmid cloning and ligation

Written by SignalsLab

Early edition: these lessons are being reviewed.

Content

Summary

Plasmid cloning inserts a DNA fragment of interest into a circular plasmid vector using restriction enzymes and DNA ligase. The recombinant plasmid is then introduced into bacteria, which copy it as they divide. Success depends on compatible ends, correct insert-to-vector ratios, and selection of the right colonies.

Intuition

Think of a plasmid as a small circular ring of DNA and the insert as a puzzle piece. A restriction enzyme cuts the ring and the donor DNA at specific sequences, leaving matching sticky ends that can base-pair like complementary jigsaw edges. These ends only hold loosely through hydrogen bonds, so DNA ligase seals the sugar-phosphate backbone with phosphodiester bonds, using ATP. Once the ring is closed again, it carries the new piece and bacteria copy it every time they divide. Geometry matters: the ends must be complementary, the insert must face the right direction, and the ring must close without leaving nicks.

Key equations

ng insert=ratio×ng vector×length of insert (bp)length of vector (bp)
(1)

Mass of insert needed for a chosen molar insert:vector ratio, commonly 3:1.

DNA-3'-OH+5'-P-DNA+ATP→DNA-3'-O-P-5'-DNA+AMP+PPi
(2)

Ligase forms a phosphodiester bond between adjacent 3' hydroxyl and 5' phosphate groups.

Number of fragments=number of cuts in linear DNA+1
(3)

Cutting a linear DNA n times gives n+1 pieces; cutting a circular plasmid n times gives n pieces.

Derivation

  1. Choose an enzyme, such as EcoRI, that recognises GAATTC and cuts between G and A on each strand.
  2. Because the site is palindromic, the cut leaves a 5' overhang AATT on both ends of each fragment.
  3. Cut vector and insert DNA with the same enzyme so that their overhangs are complementary.
  4. Mix them; overhangs anneal by hydrogen bonding, bringing a 3' OH next to a 5' phosphate.
  5. T4 DNA ligase uses ATP to join these groups, forming a phosphodiester bond on each strand and closing the backbone.
  6. Convert the desired 3:1 molar ratio to mass using the lengths of insert and vector.
  7. Transform competent bacteria and plate on antibiotic to select cells that took up plasmid.

Worked example

Problem

You have 50 ng of a 3000 bp vector. How many ng of a 1000 bp insert give a 3:1 insert:vector molar ratio?

  1. Use ng insert = ratio × ng vector × (insert length / vector length).
  2. Substitute: 3 × 50 × (1000/3000).
  3. Compute 1000/3000 = 0.3333.
  4. Then 3 × 50 × 0.3333 = 50.

Answer 50 ng of insert

Common mistakes

  • Using a 1:1 mass ratio instead of a molar ratio, which gives too few insert molecules for a short insert.
  • Forgetting to dephosphorylate the vector when using a single enzyme, which lets the vector re-ligate to itself and gives many empty colonies.
  • Cutting with enzymes that leave incompatible overhangs, or forgetting that a single-enzyme insert can ligate in either orientation.
  • Using old ligase buffer in which ATP has degraded, so ligation fails.
  • Not heat-inactivating or removing the enzyme, or carrying over salts that inhibit ligation or transformation.

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 *

# Cut a plasmid and an insert with EcoRI, then ligate; sequences computed by code.
SITE = "GAATTC"


def cut_sites(seq, site=SITE):
    """Return cut positions (after G, i.e. G^AATTC) in seq."""
    out, i = [], seq.find(site)
    while i != -1:
        out.append(i + 1)
        i = seq.find(site, i + 1)
    return out


def digest(seq):
    """Cut a linear sequence at EcoRI sites; return fragments."""
    cuts = cut_sites(seq)
    pts = [0] + cuts + [len(seq)]
    return [seq[a:b] for a, b in zip(pts[:-1], pts[1:])]


def ligate(fragments):
    """Join fragments end to end."""
    return "".join(fragments)


PLASMID = "ATGCCGAATTCGGTACC"
INSERT = "TTGAATTCAAGCTTGAATTCCA"
P_FRAGS = digest(PLASMID)
I_FRAGS = digest(INSERT)
RECOMB = ligate([P_FRAGS[0], I_FRAGS[1], P_FRAGS[1]])


class Main(Scene):
    def construct(self):
        self.camera.background_color = "#14161c"
        TitleCard(self, "Plasmid cloning", "Cut with EcoRI, then ligate")
        # circular plasmid
        ring = Circle(radius=1.4, color=C_MAIN, stroke_width=8).shift(LEFT * 3.5 + DOWN * 0.2)
        pl = Text("Plasmid", font_size=24).move_to(ring)
        site = Dot(ring.point_at_angle(PI / 2), color=C_BAD, radius=0.12)
        site_t = Text("EcoRI site", font_size=24, color=C_BAD).next_to(site, UP, buff=0.15)
        self.play(Create(ring), FadeIn(pl))
        self.play(FadeIn(site), FadeIn(site_t))
        # linear insert
        ins = Rectangle(width=3.2, height=0.5, color=C_GOOD, fill_opacity=0.5)
        ins.shift(RIGHT * 3.5 + DOWN * 0.2)
        ins_t = Text("Insert (gene)", font_size=24).next_to(ins, UP, buff=0.3)
        self.play(FadeIn(ins), FadeIn(ins_t))
        StepCaption(self, "EcoRI cuts G^AATTC and leaves sticky ends")
        # cut: open ring into an arc
        arc = Arc(radius=1.4, start_angle=PI / 2 + 0.5, angle=TAU - 1.0,
                  color=C_MAIN, stroke_width=8).move_to(ring)
        self.play(FadeOut(site), FadeOut(site_t), FadeOut(pl), Transform(ring, arc))
        self.play(ins.animate.move_to(ring.get_center() + UP * 1.4), FadeOut(ins_t))
        StepCaption(self, "DNA ligase seals the backbone around the insert")
        closed = Circle(radius=1.4, color=C_MAIN, stroke_width=8).move_to(ring.get_center())
        self.play(Transform(ring, closed), ins.animate.set_color(C_ACCENT))
        res = Text(f"Recombinant: {len(RECOMB)} bp", font_size=28,
                   color=C_ACCENT).to_edge(RIGHT, buff=0.6)
        self.play(FadeIn(res))
        StepCaption(self, "Cut, mix, ligate: the gene now lives in the plasmid")
        self.wait(1)


if __name__ == "__main__" and "--selftest" in sys.argv:
    assert cut_sites(PLASMID) == [6]
    assert P_FRAGS == ["ATGCCG", "AATTCGGTACC"]
    assert ligate(P_FRAGS) == PLASMID
    assert cut_sites(INSERT) == [3, 15]
    assert I_FRAGS[1] == "AATTCAAGCTTG"
    assert ligate(I_FRAGS) == INSERT
    assert RECOMB.count(SITE) == 2
    assert len(RECOMB) == 29
    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.