# DNA replication: copying 3 billion letters without typos

> A process map exported from forks.world (https://forks.world). Author: Brian. Source: https://forks.world/p/cmv0idzq1000ojw06ogp8w0pn
> It describes who does what, in what order, and with which technology. Read the plain-language sections first; the JSON at the end is the exact, complete data.

## Summary

- 23 steps across 3 layers
- Persona: The cell, Helicase (the unzipper), Primase, DNA polymerase (the builder), Ligase (the stitcher)
- Technology / systems: The DNA

## How to read this file

- A process is made of **layers**. The main layer is the top level; any step of kind `subprocess` opens a detail layer with its own lanes and steps.
- **Lanes** are either persona (people/roles) or technology (systems). Each step belongs to one lane; `using` lists tools a person uses for that step.
- Step kinds: `start`, `task`, `decision` (its arrows carry the answer as a label), `subprocess`, `end`.

## DNA replication: copying 3 billion letters without typos

Lanes:
- The cell: person / role (id `cell`)
- Helicase (the unzipper): person / role (id `hel`)
- Primase: person / role (id `pri`)
- DNA polymerase (the builder): person / role (id `pol`)
- Ligase (the stitcher): person / role (id `lig`)
- The DNA: technology / system (id `dna`)

Steps, in the order they run:

1. **A signal says: time to divide** [start; The cell; id `d1`]
   - then Helicase unzips the double helix at the origin
2. **Helicase unzips the double helix at the origin** [task; Helicase (the unzipper); id `d2`]
   - then The replication fork opens
3. **The replication fork opens** [task; The DNA; id `d3`]
   - then Primase lays down short RNA primers
4. **Primase lays down short RNA primers** [task; Primase; id `d4`]
   - then Polymerase builds the new strands
5. **Polymerase builds the new strands** [subprocess; DNA polymerase (the builder); id `d5`], opens the detail layer "Leading and lagging strands"
   - then Proofreading: was that the right base?
6. **Proofreading: was that the right base?** [decision; DNA polymerase (the builder); id `d6`]
   - if "Yes" go to Ligase stitches the fragments together; if "No" go to Back up, snip out the wrong base and replace it
7. **Ligase stitches the fragments together** [task; Ligase (the stitcher); id `d7`]
   - then Mismatch-repair crew does a final scan
8. **Mismatch-repair crew does a final scan** [task; The cell; id `d8`]
   - then Is the copy perfect?
9. **Is the copy perfect?** [decision; The cell; id `d9`]
   - if "Yes" go to Two identical DNA molecules, ready for two new cells; if "No" go to Repair enzymes cut out and fix the error
10. **Two identical DNA molecules, ready for two new cells** [end; The DNA; id `d10`]
11. **Repair enzymes cut out and fix the error** [task; The cell; id `d8a`]
   - then Mismatch-repair crew does a final scan
12. **Back up, snip out the wrong base and replace it** [task; DNA polymerase (the builder); id `d6a`]
   - then Proofreading: was that the right base?

```mermaid
flowchart LR
  subgraph l_cell["The cell"]
    n_d1(["A signal says: time to divide"])
    n_d8["Mismatch-repair crew does a final scan"]
    n_d9{"Is the copy perfect?"}
    n_d8a["Repair enzymes cut out and fix the error"]
  end
  subgraph l_hel["Helicase (the unzipper)"]
    n_d2["Helicase unzips the double helix at the origin"]
  end
  subgraph l_pri["Primase"]
    n_d4["Primase lays down short RNA primers"]
  end
  subgraph l_pol["DNA polymerase (the builder)"]
    n_d5[["Polymerase builds the new strands"]]
    n_d6{"Proofreading: was that the right base?"}
    n_d6a["Back up, snip out the wrong base and replace it"]
  end
  subgraph l_lig["Ligase (the stitcher)"]
    n_d7["Ligase stitches the fragments together"]
  end
  subgraph l_dna["The DNA"]
    n_d3["The replication fork opens"]
    n_d10(["Two identical DNA molecules, ready for two new cells"])
  end
  n_d1 --> n_d2
  n_d2 --> n_d3
  n_d3 --> n_d4
  n_d4 --> n_d5
  n_d5 --> n_d6
  n_d6 -->|"Yes"| n_d7
  n_d6 -->|"No"| n_d6a
  n_d6a --> n_d6
  n_d7 --> n_d8
  n_d8 --> n_d9
  n_d9 -->|"Yes"| n_d10
  n_d9 -->|"No"| n_d8a
  n_d8a --> n_d8
```

### Okazaki fragments (detail of step "Builds short Okazaki fragments, backwards, in bursts")

Lanes:
- Helicase (the unzipper): person / role (id `hel`)
- Primase: person / role (id `pri`)
- DNA polymerase (the builder): person / role (id `pol`)
- The DNA: technology / system (id `dna`)

Steps, in the order they run:

1. **Primase drops a fresh primer** [start; Primase; id `o1`]
   - then Polymerase builds about 150 bases back toward the last fragment
2. **Polymerase builds about 150 bases back toward the last fragment** [task; DNA polymerase (the builder); id `o2`]
   - then Reached the previous fragment?
3. **Reached the previous fragment?** [decision; DNA polymerase (the builder); id `o3`]
   - if "Yes" go to Detach and hop forward to the next primer; if "No — keep building" go to Polymerase builds about 150 bases back toward the last fragment
4. **Detach and hop forward to the next primer** [task; DNA polymerase (the builder); id `o4`]
   - then Has helicase opened more DNA?
5. **Has helicase opened more DNA?** [decision; Helicase (the unzipper); id `o5`]
   - if "Yes" go to Primase drops a fresh primer; if "No" go to Lagging strand done
6. **Lagging strand done** [end; The DNA; id `o6`]

```mermaid
flowchart LR
  subgraph l_hel["Helicase (the unzipper)"]
    n_o5{"Has helicase opened more DNA?"}
  end
  subgraph l_pri["Primase"]
    n_o1(["Primase drops a fresh primer"])
  end
  subgraph l_pol["DNA polymerase (the builder)"]
    n_o2["Polymerase builds about 150 bases back toward the last fragment"]
    n_o3{"Reached the previous fragment?"}
    n_o4["Detach and hop forward to the next primer"]
  end
  subgraph l_dna["The DNA"]
    n_o6(["Lagging strand done"])
  end
  n_o1 --> n_o2
  n_o2 --> n_o3
  n_o3 -->|"Yes"| n_o4
  n_o3 -->|"No — keep building"| n_o2
  n_o4 --> n_o5
  n_o5 -->|"Yes"| n_o1
  n_o5 -->|"No"| n_o6
```

### Leading and lagging strands (detail of step "Polymerase builds the new strands")

Lanes:
- DNA polymerase (the builder): person / role (id `pol`)
- The DNA: technology / system (id `dna`)

Steps, in the order they run:

1. **Polymerase reads the template strand** [start; DNA polymerase (the builder); id `s1`]
   - then Which strand is it?
2. **Which strand is it?** [decision; The DNA; id `s2`]
   - if "Leading strand" go to Builds one smooth, continuous new strand; if "Lagging strand" go to Builds short Okazaki fragments, backwards, in bursts
3. **Builds one smooth, continuous new strand** [task; DNA polymerase (the builder); id `s3`]
   - then New strand complete
4. **New strand complete** [end; The DNA; id `s7`]
5. **Builds short Okazaki fragments, backwards, in bursts** [subprocess; DNA polymerase (the builder); id `s4`], opens the detail layer "Okazaki fragments"
   - then New strand complete

```mermaid
flowchart LR
  subgraph l_pol["DNA polymerase (the builder)"]
    n_s1(["Polymerase reads the template strand"])
    n_s3["Builds one smooth, continuous new strand"]
    n_s4[["Builds short Okazaki fragments, backwards, in bursts"]]
  end
  subgraph l_dna["The DNA"]
    n_s2{"Which strand is it?"}
    n_s7(["New strand complete"])
  end
  n_s1 --> n_s2
  n_s2 -->|"Leading strand"| n_s3
  n_s2 -->|"Lagging strand"| n_s4
  n_s3 --> n_s7
  n_s4 --> n_s7
```

## Full data (JSON)

```json
{
  "title": "DNA replication: copying 3 billion letters without typos",
  "maps": {
    "m_okaz": {
      "id": "m_okaz",
      "lanes": [
        {
          "id": "hel",
          "name": "Helicase (the unzipper)",
          "type": "person"
        },
        {
          "id": "pri",
          "name": "Primase",
          "type": "person"
        },
        {
          "id": "pol",
          "name": "DNA polymerase (the builder)",
          "type": "person"
        },
        {
          "id": "dna",
          "name": "The DNA",
          "type": "system"
        }
      ],
      "steps": [
        {
          "id": "o1",
          "kind": "start",
          "lane": "pri",
          "next": [
            {
              "to": "o2"
            }
          ],
          "uses": [],
          "label": "Primase drops a fresh primer"
        },
        {
          "id": "o2",
          "kind": "task",
          "lane": "pol",
          "next": [
            {
              "to": "o3"
            }
          ],
          "uses": [],
          "label": "Polymerase builds about 150 bases back toward the last fragment"
        },
        {
          "id": "o3",
          "kind": "decision",
          "lane": "pol",
          "next": [
            {
              "to": "o4",
              "label": "Yes"
            },
            {
              "to": "o2",
              "label": "No — keep building"
            }
          ],
          "uses": [],
          "label": "Reached the previous fragment?"
        },
        {
          "id": "o4",
          "kind": "task",
          "lane": "pol",
          "next": [
            {
              "to": "o5"
            }
          ],
          "uses": [],
          "label": "Detach and hop forward to the next primer"
        },
        {
          "id": "o5",
          "kind": "decision",
          "lane": "hel",
          "next": [
            {
              "to": "o1",
              "label": "Yes"
            },
            {
              "to": "o6",
              "label": "No"
            }
          ],
          "uses": [],
          "label": "Has helicase opened more DNA?"
        },
        {
          "id": "o6",
          "kind": "end",
          "lane": "dna",
          "next": [],
          "uses": [],
          "label": "Lagging strand done"
        }
      ],
      "title": "Okazaki fragments",
      "parent": {
        "map": "m_strands",
        "step": "s4"
      }
    },
    "m_root": {
      "id": "m_root",
      "lanes": [
        {
          "id": "cell",
          "name": "The cell",
          "type": "person"
        },
        {
          "id": "hel",
          "name": "Helicase (the unzipper)",
          "type": "person"
        },
        {
          "id": "pri",
          "name": "Primase",
          "type": "person"
        },
        {
          "id": "pol",
          "name": "DNA polymerase (the builder)",
          "type": "person"
        },
        {
          "id": "lig",
          "name": "Ligase (the stitcher)",
          "type": "person"
        },
        {
          "id": "dna",
          "name": "The DNA",
          "type": "system"
        }
      ],
      "steps": [
        {
          "id": "d1",
          "kind": "start",
          "lane": "cell",
          "next": [
            {
              "to": "d2"
            }
          ],
          "uses": [],
          "label": "A signal says: time to divide"
        },
        {
          "id": "d2",
          "kind": "task",
          "lane": "hel",
          "next": [
            {
              "to": "d3"
            }
          ],
          "uses": [],
          "label": "Helicase unzips the double helix at the origin"
        },
        {
          "id": "d3",
          "kind": "task",
          "lane": "dna",
          "next": [
            {
              "to": "d4"
            }
          ],
          "uses": [],
          "label": "The replication fork opens"
        },
        {
          "id": "d4",
          "kind": "task",
          "lane": "pri",
          "next": [
            {
              "to": "d5"
            }
          ],
          "uses": [],
          "label": "Primase lays down short RNA primers"
        },
        {
          "id": "d5",
          "kind": "subprocess",
          "lane": "pol",
          "next": [
            {
              "to": "d6"
            }
          ],
          "uses": [],
          "child": "m_strands",
          "label": "Polymerase builds the new strands"
        },
        {
          "id": "d6",
          "kind": "decision",
          "lane": "pol",
          "next": [
            {
              "to": "d7",
              "label": "Yes"
            },
            {
              "to": "d6a",
              "label": "No"
            }
          ],
          "uses": [],
          "label": "Proofreading: was that the right base?"
        },
        {
          "id": "d6a",
          "kind": "task",
          "lane": "pol",
          "next": [
            {
              "to": "d6"
            }
          ],
          "uses": [],
          "label": "Back up, snip out the wrong base and replace it"
        },
        {
          "id": "d7",
          "kind": "task",
          "lane": "lig",
          "next": [
            {
              "to": "d8"
            }
          ],
          "uses": [],
          "label": "Ligase stitches the fragments together"
        },
        {
          "id": "d8",
          "kind": "task",
          "lane": "cell",
          "next": [
            {
              "to": "d9"
            }
          ],
          "uses": [],
          "label": "Mismatch-repair crew does a final scan"
        },
        {
          "id": "d9",
          "kind": "decision",
          "lane": "cell",
          "next": [
            {
              "to": "d10",
              "label": "Yes"
            },
            {
              "to": "d8a",
              "label": "No"
            }
          ],
          "uses": [],
          "label": "Is the copy perfect?"
        },
        {
          "id": "d8a",
          "kind": "task",
          "lane": "cell",
          "next": [
            {
              "to": "d8"
            }
          ],
          "uses": [],
          "label": "Repair enzymes cut out and fix the error"
        },
        {
          "id": "d10",
          "kind": "end",
          "lane": "dna",
          "next": [],
          "uses": [],
          "label": "Two identical DNA molecules, ready for two new cells"
        }
      ],
      "title": "DNA replication: copying 3 billion letters without typos",
      "parent": null
    },
    "m_strands": {
      "id": "m_strands",
      "lanes": [
        {
          "id": "pol",
          "name": "DNA polymerase (the builder)",
          "type": "person"
        },
        {
          "id": "dna",
          "name": "The DNA",
          "type": "system"
        }
      ],
      "steps": [
        {
          "id": "s1",
          "kind": "start",
          "lane": "pol",
          "next": [
            {
              "to": "s2"
            }
          ],
          "uses": [],
          "label": "Polymerase reads the template strand"
        },
        {
          "id": "s2",
          "kind": "decision",
          "lane": "dna",
          "next": [
            {
              "to": "s3",
              "label": "Leading strand"
            },
            {
              "to": "s4",
              "label": "Lagging strand"
            }
          ],
          "uses": [],
          "label": "Which strand is it?"
        },
        {
          "id": "s3",
          "kind": "task",
          "lane": "pol",
          "next": [
            {
              "to": "s7"
            }
          ],
          "uses": [],
          "label": "Builds one smooth, continuous new strand"
        },
        {
          "id": "s4",
          "kind": "subprocess",
          "lane": "pol",
          "next": [
            {
              "to": "s7"
            }
          ],
          "uses": [],
          "child": "m_okaz",
          "label": "Builds short Okazaki fragments, backwards, in bursts"
        },
        {
          "id": "s7",
          "kind": "end",
          "lane": "dna",
          "next": [],
          "uses": [],
          "label": "New strand complete"
        }
      ],
      "title": "Leading and lagging strands",
      "parent": {
        "map": "m_root",
        "step": "d5"
      }
    }
  }
}
```