Putting it together: gene expression end to end

You have built every part on its own. You have seen DNA store a sequence, watched a polymerase copy it into RNA, learned how the ribosome reads three letters at a time, and traced a chain of amino acids folding into a working shape. This lesson does one thing. It runs all of it as a single continuous story. One gene, start to finish, in one take. No new machinery. Just the whole pipeline moving at once, so the pieces stop feeling like separate facts and start feeling like one process with a name.

That name is gene expression. Here is the honest test of whether you understand this module: close this page and narrate the whole thing back from memory, in order, out loud. If you can do that, you own the material. This lesson exists to get you there.

Keep this map in view as we go. Trace along it with your eye at each step.

The gene, at rest

Start in the nucleus. Somewhere on one of your chromosomes sits a gene: a stretch of DNA that codes for a protein (sometimes more than one, as S5.4 showed with alternative splicing). Right now it is doing nothing. It is text sitting on a disk. Just in front of it sits a short control sequence called the promoter. The promoter is not part of the protein recipe. It is a landing pad, a piece of DNA whose only job is to say "a gene begins here, read from this point in this direction."

Nothing happens to the gene until something recognizes that promoter. That recognition is the ignition switch for everything below.

Step 1: The promoter is read, and transcription begins

Proteins called transcription factors find the promoter and assemble on it, and they recruit the copying machine, RNA polymerase. Once the polymerase is docked and pointed the right way, it opens the double helix and starts moving along the gene, reading the template strand and building a matching RNA copy as it goes, 5 prime to 3 prime.

What comes off the end is not the finished message. It is a raw first draft called pre-mRNA (the "pre" means it still needs editing). It contains the whole gene copied out, including stretches that will not survive to the final product.

Step 2: The transcript gets edited

Before this draft can leave the nucleus, three edits happen to it.

A cap is added to the front. A special modified building block is stuck onto the 5 prime end, the 5 prime cap. It protects the front of the message from being chewed up, and later it is the handle the ribosome grabs.

The middle gets spliced. The pre-mRNA is not one clean recipe. It is the real coding stretches (exons) interrupted by filler stretches (introns) that must come out. A machine called the spliceosome snips out every intron and stitches the exons together into one continuous coding message. This is also where the same gene can yield more than one protein, by keeping different combinations of exons, but hold that thought for later modules.

A tail is added to the back. Many copies of one letter, adenine, are added to the 3 prime end, the poly-A tail. It stabilizes the message and helps carry it out of the nucleus.

Now the raw draft is a mature mRNA: capped, spliced, tailed, ready to ship.

Step 3: Export to the cytoplasm

The mature mRNA now leaves. The nucleus is a walled room, and its wall is studded with gates called nuclear pores. The finished mRNA is passed through a pore out into the cytoplasm, the main body of the cell, where the ribosomes live. This move matters: in your cells, the reading of the gene and the building of the protein happen in two different rooms. The message has to physically travel from one to the other.

Step 4: The ribosome finds the start codon and translates

Out in the cytoplasm, a ribosome loads onto the mRNA. It latches onto that 5 prime cap and scans along the message looking for the start signal, the start codon, which reads AUG. This is where the count begins. Everything before AUG is a leader the ribosome slides past. AUG says "the protein starts here, and read three letters at a time from now on."

Then translation runs. For each three-letter codon, a matching transfer RNA (tRNA) shows up carrying the one amino acid that codon calls for, its anticodon pairing against the codon to guarantee the right delivery. The ribosome links each new amino acid onto the growing chain and ratchets one codon forward. Codon, amino acid, bond, step. Codon, amino acid, bond, step. A protein is being spelled out, one residue per three letters of message.

Run this step yourself before reading on. Type or keep the default mRNA, step through it, and predict the next amino acid from the codon before the tool reveals it. If you can call the amino acids ahead of the machine, you have internalized the reading frame.

// translate.ts: the ribosome as a loop over codons
const CODON_TABLE: Record<string, string> = {
  AUG: "M", GCA: "A", CUG: "L", ACC: "T",
  UAA: "*", UAG: "*", UGA: "*", /* ...all 64 codons... */
};

function translate(mrna: string): string {
  const rna = mrna.toUpperCase().replace(/T/g, "U");
  let protein = "";
  for (let i = 0; i + 3 <= rna.length; i += 3) {
    const aa = CODON_TABLE[rna.slice(i, i + 3)] ?? "X";
    if (aa === "*") break; // ribosome releases at the first stop
    protein += aa;
  }
  return protein;
}

translate("AUGGCACUGACCUAA"); // "MALT"

Step 5: Stop, release, and fold

Eventually the ribosome hits one of three special codons: UAA, UAG, or UGA. These are stop codons, and here is the elegant part. No tRNA carries an amino acid for them. Nothing can pair. Instead a protein called a release factor slips into that empty slot, and its arrival tells the ribosome to cut the finished chain loose. The ribosome lets go, the pieces come apart, and a fresh linear chain of amino acids drifts free.

A linear chain is not yet a working protein. As you saw back in the folding lesson, that chain collapses into its three-dimensional shape, driven by its own sequence and often helped along by folding-assistant proteins called chaperones. Only once it is folded does it have the pocket, the surface, or the channel that does its job. Sequence became chain. Chain becomes shape.

Step 6: Cut, tag, and deliver

For many proteins there is one more stage before work: modification and transport. The cell may trim pieces off the chain, add chemical tags to it (a phosphate, a sugar), or ship it to a specific address. Insulin is a clean example. It is built as a longer chain, then cut down, before it becomes the hormone that actually leaves the cell. A protein bound for the membrane or for export is routed and finished on the way. These steps are optional in the sense that not every protein needs them, but for the ones that do, the protein is not truly done until they happen.

Then the protein does its job

And now it works. The folded, finished protein is an enzyme speeding a reaction, a channel passing ions, a motor pulling cargo, a receptor catching a signal. The information that started as inert DNA has become action in the cell. That entire journey, from a gene at rest to a working protein doing its task, is what the phrase gene expression means. Expression is not one step. It is the whole pipeline.

The programmer analogy, and where it breaks

Line the whole thing up against a real software build-and-run. The gene is source code on disk. Transcription is the build reading the source. Capping, splicing, and the poly-A tail are a preprocess and link pass that strips comments and dead sections and packages a shippable artifact. Export through the nuclear pore is loading that artifact off disk into memory. Translation is the interpreter turning the loaded bytes into a live, running process. Folding and modification are that process initializing its internal state. Then the protein runs and does work. Source, build, load, run, work. It is a genuinely good map, and it is why "the gene does X" is a category error the same way "the source file does X" is: the file just sits there, the running process is what acts.

Now the failure edge, because an analogy without its limit is a bug. A software build is deterministic and complete: the same source compiles to the same binary every time, and nothing along the way is optional. This pipeline is neither. The splice step can assemble different products from one gene, the modification step is skipped for some proteins and required for others, and above all, whether the build runs at all and how many copies it makes is not fixed by the source. A compiler does not decide, based on the cell it finds itself in, to build your code ten thousand times or not once. This one does. So keep the pipeline shape and drop the assumption that the source determines the output.

Every step is a control point

Here is the payoff of telling the story as one continuous pipeline. Every hand-off you just traced is a place the cell can intervene. It can refuse to let a transcription factor reach the promoter, so nothing is copied. It can hold the mRNA back from export, or destroy it before a ribosome ever loads, or slow the ribosome down, or tear the finished protein apart early. A pipeline with this many stages is a pipeline with this many knobs. That is not an accident. That is the point. It is how one fixed genome runs thousands of different cells.