Protein Synthesis Explained: DNA Transcription & Translation

Right now, inside almost every cell in your body, a strand of DNA is sitting in a locked room called the nucleus and never coming out. And yet somehow that DNA is responsible for building literally every protein you're made of: the collagen in your skin, the hemoglobin in your blood, the enzymes digesting your last meal. How does a molecule that never leaves the room end up building everything outside it?

The short answer is that DNA doesn't build anything directly. It gets copied, and the copy does the work. Let's build up exactly how that copying and building happens, one step at a time.

DNA is the reference copy, not the working copy

Think of DNA as the master recipe book in a restaurant, kept locked in a back office. Nobody is allowed to carry the original book into the kitchen. It's too valuable and there's only one. Damage it, lose a page, and the whole restaurant is in trouble.

So instead, whenever the kitchen needs one specific recipe, a scribe goes into the office, copies out just that one recipe onto a disposable card, and carries the card to the kitchen. The original book never moves. Only the copy does.

Your cells run the same setup. DNA stays in the nucleus, permanently. When a cell needs to build a specific protein, it copies out just the one gene it needs onto a shorter, disposable molecule called messenger RNA, or mRNA. That copy leaves the nucleus and heads to the cell's protein-building machinery. The DNA itself never goes anywhere.

This is the whole reason the process needs two separate stages. Transcription is the scribe copying the recipe. Translation is the kitchen turning that recipe into an actual dish. Copying a recipe and cooking from it are different skills, done by different machinery, in different rooms of the cell. Let's take them one at a time.

Transcription is the cell rewriting one recipe onto a portable copy

DNA is a double strand, two backbones wound around each other, held together by bases pairing up in the middle: $A$ pairs with $T$, and $G$ pairs with $C$. To copy a gene, the cell can't just read a sealed double strand. It has to open it up first.

An enzyme called RNA polymerase lands on the DNA and does exactly that. It pries the two strands apart, forming a small bubble, and reads one of the exposed strands, called the template strand, letter by letter. For every base it reads, it grabs a matching RNA base and clicks it into place, building a brand new single strand as it goes.

There's one twist worth noticing. RNA doesn't use the base $T$ at all. Everywhere DNA would use thymine, RNA uses a close cousin called uracil, written $U$. So the pairing rule while copying is $A:U$, $U:A$, $G:C$, and $C:G$, not the DNA pairing rule of $A:T$. That's the one letter swap that turns a DNA sequence into an RNA sequence.

Press play and watch the polymerase move along the template strand. Every base it reads gets a partner base added to the growing mRNA strand below, using the RNA pairing rule instead of the DNA one. By the time it reaches the end, the mRNA strand is a complete, portable copy of that one gene, ready to leave the nucleus.

The message is read three letters at a time, and where you start matters

Once mRNA reaches the ribosome, the cell has to turn a string of four possible letters, $A$, $U$, $G$, $C$, into a sequence of amino acids. There are only 4 RNA letters but 20 different amino acids to choose from, so reading one letter at a time can't possibly cover all 20 options. $4^1$ is only 4.

Two letters at a time still isn't enough. $4^2$ gives you 16 combinations, still short of 20. But three letters at a time gives $4^3 = 64$ possible combinations, more than enough to cover every amino acid with room to spare. So the cell reads mRNA in non-overlapping groups of three, called codons, and each codon points to exactly one amino acid, or to a stop signal that ends the chain.

Here's the part that trips people up: the ribosome doesn't know where one codon "should" begin. It just starts at whatever base it starts at, and counts three at a time from there. Grab a random sentence and try the same trick. Take THECATSAWTHEDOG and split it into groups of three starting from the first letter: THE CAT SAW THE DOG. Real words. Now start from the second letter instead: HEC ATS AWT HED OG. Complete gibberish, using the exact same letters. Nothing about the letters changed. Only where you started counting changed.

That starting point is called the reading frame, and mRNA has exactly the same vulnerability as that sentence.

The mRNA above is the same twelve letters no matter which button you press. Frame +0 groups it into AUG, GGU, UGG, UAA, which reads as methionine, glycine, tryptophan, then stop, a real three-amino-acid protein. Shift the frame by even one base and every single codon downstream changes, because the groupings of three no longer land in the same places. The letters never moved. Only where the counting started did.

Not every single-letter typo changes the protein

So if reading frame is this sensitive, what happens when a single DNA letter gets copied wrong, a real mutation? You might expect every typo to wreck the protein. It doesn't, and the reason comes straight back to that $4^3 = 64$ number.

There are 64 possible codons, but only 20 amino acids and one stop signal to assign them to. That means, on average, each amino acid gets covered by about three different codons, not just one. Biologists call this redundancy, or degeneracy of the genetic code. And it isn't spread evenly. The third letter of a codon is far more forgiving than the first two, a pattern called the wobble position, because the machinery reading that third letter is looser about which base it accepts.

That redundancy is what decides whether a mutation actually matters. Change a base and get a codon for the same amino acid, and the protein comes out identical. Biologists call that a silent mutation. Change a base and land on a codon for a different amino acid, and you get a missense mutation, a real change to the protein. Land on a stop codon instead, and you get a nonsense mutation, which cuts the protein short entirely.

Try mutating the third letter of GGU. It stays glycine no matter what you change it to, because all four codons starting with GG code for glycine. That's the wobble position at work: a silent mutation, guaranteed. Now try the first letter instead. Every single option gives you a different amino acid. And if you mutate the third letter of UGG, watch what happens when you land on UGA. Same position, same kind of one-letter swap, but this time it's a nonsense mutation: tryptophan only has one codon, so it has nowhere safe to fall.

Translation is an assembly line, one amino acid at a time

Now for the actual building. The ribosome sits on the mRNA like a reader moving along a strip of text, and it processes exactly one codon at a time. But the ribosome itself can't tell an amino acid from a codon. It needs a translator in between, and that job belongs to a molecule called transfer RNA, or tRNA.

Each tRNA is a small adapter with two working ends. One end carries a specific amino acid. The other end carries a three-base sequence called an anticodon, built to pair up with exactly one codon on the mRNA, the same $A:U$, $G:C$ rule from transcription. When the ribosome exposes a codon, only the tRNA with a matching anticodon can dock there. Whatever amino acid that tRNA happens to be carrying gets attached to the end of the growing chain, and the ribosome slides forward to the next codon.

This keeps going, one codon, one matching tRNA, one amino acid added, until the ribosome reaches a stop codon. No tRNA matches a stop codon on purpose. Instead, a release factor steps in, snips the finished chain free, and the new protein floats away to start folding into its working shape.

Step through the four codons above, or hit play and let it run. Watch how AUG, the start codon, brings in methionine first, then GGU brings in glycine, then UGG brings in tryptophan, each one hooking onto the end of the chain. When the ribosome hits UAA, no tRNA shows up. The chain just gets released. Three codons, three amino acids, one small protein, built one link at a time.

The short version

DNA stays locked in the nucleus and never builds anything directly. A cell copies the one gene it needs onto a disposable mRNA strand, swapping $T$ for $U$ as it goes: that's transcription. A ribosome then reads that mRNA three letters at a time, and only three letters at a time, because $4^3 = 64$ is the smallest grouping that can cover 20 amino acids. Shift where that counting starts, and the whole message scrambles, even though not a single letter changed.

Along the way, some single-letter mutations do nothing at all, thanks to the genetic code's built-in redundancy, especially at the third position of a codon. Others swap in a wrong amino acid, or cut the protein short entirely. And the actual building happens as an assembly line: tRNA molecules matching codon to amino acid, one link added at a time, until a stop codon ends the chain and releases a finished protein.

Copy the recipe, carry it to the kitchen, read it three letters at a time, build the dish. That's protein synthesis, and now you've seen every stage of it happen.