The Most Common Ladder Logic Mistakes — What 10,000 Graded Attempts Taught Us

Across 10,272 graded ladder logic attempts on our browser PLC simulator, the most common mistake by far was an output that never turns on: 58% of failed runs ended with a graded output stuck FALSE — usually a missing or mis-addressed rung. And 83% of all failures happened within two seconds of clicking Run.

Every attempt in this study is a real grading run by a real learner, captured by our auto-grader between the simulator's launch and 2026-07-10. Because the grader records why each run failed — which tag had the wrong value, and on which test case — we can do something most "top PLC mistakes" articles cannot: rank the mistakes by how often they actually happen, instead of by gut feel.

This post is the full write-up: the numbers, a named taxonomy of the mistakes, what each one looks like on a rung, and how to fix it.

The headline numbers

| Metric | Value | |---|---| | Total grading runs recorded | 10,272 | | Runs reaching a pass/fail verdict | 7,977 | | Passed | 4,262 (53.4% of graded) | | Failed | 3,715 (46.6% of graded) | | Runs with no final verdict recorded (status "running") | 2,295 | | Failures graded in under 2 seconds | 3,085 (83.0% of failures) | | Failures taking over 2 seconds | 592 (15.9% of failures) | | Most common failure message | "output = false, expected true" (2,171 runs) | | Learners passing on their very first try | 1,493 | | Dialect used | IEC 61131-3 in 94.6% of runs |

Two honesty notes before we go further, because this is a data post and the caveats matter:

• 2,295 runs (22.3% of the total) show status "running" — grading started but no final verdict was recorded, typically because the learner navigated away or reset mid-grade. All pass-rate percentages below use only the 7,977 runs that reached a verdict.
• The failure categories below overlap. One attempt can embody several mistakes (a wrong contact type and a missing rung), but the grader records the first failing assertion it hits. Percentages therefore do not sum to 100.

One more thing surprised us. We exported the top 60 most frequent failure messages, normalized so that tag names and numbers become placeholders — expecting a long tail of 60 distinct error shapes. After normalization, almost everything collapsed into just two patterns: "output = false, expected true" (2,171 runs) and "output = true, expected false" (990 runs), plus two rare scenario-specific state checks (9 runs combined). 545 failed runs (14.7%) produced no normalized assertion message at all — likely runs that failed before any test case could assert. In other words: at the grader's level of visibility, nearly every ladder logic failure is one of two things — the output never came on, or it never went off. The taxonomy below breaks those two umbrellas into the specific mistakes underneath them, using per-scenario pass rates as the evidence.

The mistake taxonomy, ranked

1. Running before writing: the two-second fail — 83% of failures

3,085 of 3,715 failed runs (83.0%) were graded in under two seconds. A grading run only takes that little time when the ladder fails the very first test cases immediately — an empty or near-empty ladder, a rung that references the wrong tag, or a Run click to "see what happens" before the logic exists. (Scenarios that genuinely need time to grade show it: our timed traffic light scenario averages 8.5 seconds per grading run, because the grader must watch the sequence play out.)

Some of this is healthy experimentation — clicking Run early to see the test cases is a legitimate strategy. But the sheer volume tells us many learners treat Run as "show me the answer" rather than "check my answer."

The fix: read the scenario brief and identify the graded output tags before placing your first contact. Every graded output needs at least one rung that can drive it. If you are brand new, the free lesson track walks you through your first rungs one instruction at a time, and you can try the simulator without an account.

2. The output that never turns on — 58% of failures

2,171 failed runs (58.4% of all failures; 68.5% of normalized failure messages) ended with "output = false, expected true": the grader flipped the inputs, waited, and the graded output simply never energized. On real hardware this is the machine that does nothing when you press Start.

The underlying causes we see when reviewing ladders in this bucket:

• No rung drives the graded tag at all — the output coil was never placed, or was placed with a misspelled/wrong tag name, so the grader's tag never changes.
• The rung exists but its conditions can never all be true — two contacts on the same input where one is NO and one is NC, or an input the scenario never turns on.
• The logic is on the wrong rung — conditions ANDed in series when the scenario needs OR (parallel branches).

The fix: for each graded output, trace one continuous left-to-right path of true conditions to its coil. If you cannot draw that path with your finger for the test case's inputs, the PLC cannot either. Our guide to reading ladder logic teaches exactly this tracing habit, and the OTE (Output Energize) reference covers the rules for driving outputs — including why the same coil on two rungs causes the last-scanned rung to win.

3. The output that will not turn off — 27% of failures

990 failed runs (26.6% of failures; 31.2% of normalized messages) were the mirror image: "output = true, expected false". The lamp that stays lit, the motor that ignores the Stop button. Three mistakes dominate here:

• NC/NO inversion — using a normally-closed contact where a normally-open belongs, so the output is on by default (more on this in mistake 5).
• A stop condition that does not break the circuit — the Stop contact placed in a parallel branch instead of in series with the whole rung, so the seal-in path bypasses it.
• A latch that is set but never reset — SET/OTL without a matching RESET/OTU path (see the OTL/OTU reference).

The fix: for every output, ask not only "what turns this on?" but "what turns it off, and is that condition wired in series so nothing can bypass it?"

4. The seal-in wall — the hardest concept in the data

If the study has one clear boss fight, it is the seal-in (latching) circuit. Compare graded pass rates:

| Scenario | Graded attempts | Pass rate | |---|---|---| | Switch → light (baseline) | 2,634 | 80.3% | | Latch with Start only | 318 | 68.6% | | Latch with Start and Stop | 631 | 23.5% | | Motor start/stop (classic 3-wire) | 679 | 18.7% |

Learners handle the latching half — a parallel branch of the output around the Start button — reasonably well (68.6% pass). The pass rate collapses to 23.5% the moment a Stop button must break the latch, and the classic industrial motor start/stop circuit — the most-attempted realistic machine scenario in the dataset, with 823 grading runs — passes only 18.7% of the time. The recurring bug: the Stop contact placed where the seal-in branch can route around it, so the motor latches on and never stops (feeding mistake 3 above).

The fix: the Stop contact goes in series with the entire rung — after the point where the Start branch and the seal-in branch rejoin. We wrote a dedicated illustrated guide: Seal-in rungs explained.

5. NC/NO contact inversion

Our normally-closed contact drill (beginner-04) passes just 52.7% of the time, versus 80.3% for the structurally identical normally-open drill — the concept alone knocks nearly 28 points off the pass rate. The confusion is always the same: an NC contact (XIO) passes power when its tag is FALSE, which feels backwards until scan-cycle thinking clicks. Get it wrong on an output rung and the output is on at power-up — a large slice of the "will not turn off" bucket in mistake 3.

The fix: memorize the examine-if rule — XIC asks "is it on?", XIO asks "is it off?" — and keep the ladder logic symbols reference open until it is automatic.

6. Timer trouble: TON presets and placement

The on-delay timer drill (beginner-08) passes only 24.7% of the time (98 of 397 graded) — nearly as brutal as the seal-in. The off-delay-flavored conveyor stop drill (beginner-09) does better at 43.2%. Typical failures: the preset in the wrong units (milliseconds vs seconds), driving the output from the timer's enable instead of its done bit Q, or resetting the timer every scan so ET never accumulates.

The fix: our TON/TOF/TP timer guide covers the pin-by-pin behavior, and TON vs TOF settles the most common "which timer do I even need?" question.

7. Counter miscounts

The counter drill (beginner-10) passes 27.5% of the time (52 of 189 graded). The classic error: counting level instead of edges — a CTU wired so it counts once per scan while the input is held true, instead of once per press. The count rockets past the preset instantly and the grader sees the done bit at the wrong time.

The fix: count rising edges. The CTU reference shows the correct one-count-per-event pattern.

8. Sequence collapse: state machines

Scenarios that require stages — do A, then B, then C — have the worst pass rates in the study:

• Garage door: 15.7% (27 of 172 graded); 5 runs failed specifically because the door never reached its up-limit.
• Car wash: 0 of 26 graded attempts passed. Not one.
• Traffic light: 45.2%, respectable only because it is heavily scaffolded.

The recurring failure is trying to write a sequence as one giant rung of ANDs instead of discrete steps, so the machine either never advances past step one or fires all stages at once.

The fix: one latch (or one bit of a step register) per stage, each stage's rung enabled by the previous stage's bit, and every stage killed by the reset condition. We now teach this as a staged traffic-light arc — build the single lamp first, then colors, then timing, then the full cycle.

9. Interlock violations: both outputs on at once

Small in absolute numbers, but scary in what it represents: 4 runs failed the explicit "were both outputs ever on simultaneously?" check, and the forward/reverse motor scenario — where energizing both contactors together is a phase-to-phase short in real life — passes just 8.3% of the time (1 of 12 graded). Learners wire both directions to run and forget the mutual exclusion.

The fix: each direction's rung must include the other direction's output as an NC contact. On real hardware you add a hardware interlock too — software interlocks alone are not accepted practice for reversing starters.

10. Jog vs. latched run confusion

The jog/run motor scenario passes only 10.5% of the time (4 of 38 graded). It demands both behaviors at once — a momentary jog (output follows the button) and a latched run — and most failed ladders latch the jog too, so the motor keeps running after the jog button is released. It is mistake 4 inverted: here the bug is a seal-in you added that should not exist.

The fix: the jog path must bypass the seal-in branch, not feed it.

How many tries does a pass take?

Of the learners who reached their first pass (within the 10-try window our export covers, 2,149 learners):

| First pass on try… | Learners | Cumulative | |---|---|---| | 1 | 1,493 | 69.5% | | 2 | 288 | 82.9% | | 3 | 143 | 89.5% | | 4–10 | 225 | 100% of window |

The median successful learner passes on their first try — remember the population here skews toward the easy first lessons. The long tail is real, though: 44 learners took eight, nine, or ten attempts before their first pass. The data does not show them quitting — it shows them iterating, which is exactly what a simulator is for. Attempt 7 on a simulated motor starter costs nothing; attempt 2 on a real one can cost a contactor.

"Ten thousand graded attempts say the hard part of ladder logic isn't the symbols — it's making an output turn off. Stop circuits, seal-ins, interlocks: nearly every classic mistake in our data is a failure to break a circuit, not to make one." — Paul, PLC Simulation Software

Methodology

• Dataset: 10,272 grading runs recorded by the auto-grader on our browser-based PLC simulator, from launch through 2026-07-10, across 40 scenarios from first-lesson drills to certification-prep exercises.
• Grading: every run executes the learner's ladder against the scenario's full test-case suite in the simulation engine (inputs driven, outputs and internal state asserted per case). A run is passed only if every test case passes.
• Failure patterns: the grader's failing assertions were normalized (tag names → TAG, numeric values → N) and aggregated. We requested the top 60 patterns; normalization collapsed them to 4 distinct shapes, which is itself a finding. 545 failed runs produced no normalized assertion (failed before any test case asserted) and are excluded from message-level percentages but included in totals and timing splits.
• Timing split: "under 2 seconds" refers to grading-run duration, our proxy for runs that failed immediately on early test cases. 38 failed runs (1.0%) had no recorded duration.
• Dialects: 94.6% of runs used IEC 61131-3 notation; Siemens (2.4%), Allen-Bradley (1.6%), and six other dialects make up the rest — too few non-IEC runs to compare mistake rates across dialects, so we have not.
• Privacy: all figures are aggregate and anonymized. No individual learner data is included or identifiable.
• Known limits: pass rates use only runs with a verdict (7,977); category percentages overlap by design; per-scenario populations differ (early lessons attract more beginners, so cross-scenario comparisons are directional, not controlled). Scenarios with under ~30 graded attempts are quoted with raw counts so you can weigh them yourself.

Want to check a number or cite this study? The aggregates above are the complete export — if you reference them, please link this page as the source.

References

• IEC 61131-3:2013, Programmable controllers — Part 3: Programming languages — the standard defining ladder diagram semantics, contacts/coils, and the TON/TOF/TP and CTU/CTD function blocks. webstore.iec.ch/en/publication/4552
• Rockwell Automation, Logix 5000 Controllers Ladder Diagram Programming Manual (publication 1756-PM008) — XIC/XIO/OTE/OTL/OTU behavior and rung-evaluation rules on Allen-Bradley platforms. literature.rockwellautomation.com
• Siemens, Programming Guideline for S7-1200/S7-1500 (Industry Online Support, entry 81318674) — vendor guidance on program structure and avoiding exactly the multiple-coil and latch pitfalls in mistakes 2–3. support.industry.siemens.com

Next steps

• Weak on the number-one killer? Read Seal-in rungs explained, then beat the real thing: the motor start/stop scenario.
• Refresh the fundamentals with the ladder logic symbols reference and the PLC instruction reference.
• Think you would beat these pass rates? Try the simulator free — the grader that produced this dataset will tell you in seconds.