DEV Community: HVAC Fitter

Pilot Light Goes Out When You Let Go? A Small Script to Sort Thermocouple From Thermopile Problems

HVAC Fitter — Tue, 10 Nov 2026 20:13:52 +0000

Every fall, the same question shows up: "My pilot lights, but it goes out the second I let go of the button." This post walks through why that happens, then turns the checks into a tiny Python helper you can adapt. It's written by the HVAC Fitter team.

Gas safety first. Turn the gas control knob and the manual supply valve off before you touch the pilot assembly, and let it cool. If you smell gas, don't flip switches or use a phone indoors. Leave and call your gas company from outside. Never bypass a safety device.

Why the flame dies when you release the button

Holding the pilot button forces the gas port open by hand. While you hold it, the pilot flame heats a sensor. That heat makes a small voltage, and the voltage powers a magnet in the gas valve. When you let go, the magnet is supposed to take over and keep the valve open.

If the flame lights while you hold the button and dies when you let go, the valve isn't getting enough voltage. The usual cause is a weak, dirty or badly placed sensor.

Thermocouple or thermopile?

These are not interchangeable:

A thermocouple is a single heat sensor that makes a tiny voltage, often around 30 mV. Its only job is holding the pilot safety magnet open. It usually screws into the valve with a threaded nut.
A thermopile (or "pilot generator") is several thermocouples joined together. Many put out roughly 600 to 750 mV, enough to run a millivolt control circuit, like a wall thermostat on a unit with no house power. It often connects with spade terminals.

So the first question is always which one you have. The part number on the old sensor, or the model number on the appliance's rating plate, settles it.

Simple things to check before buying anything

Flame contact. The pilot flame should wrap around the top part of the probe tip. A lazy or misaimed flame won't heat it enough.
Soot or corrosion. Heavy buildup on the probe can block heat.
The connection at the valve. A loose nut or terminal can drop the small voltage.
Tube length and routing. A replacement must reach the valve without stretching or kinking.

Turning it into a helper script

Here's a small, dependency-free script that turns those observations into next steps. It doesn't diagnose anything on its own. It only puts the checks above in order.

"""Pilot-out triage helper: orders the checks for a pilot that won't stay lit.
Not a substitute for a licensed technician. Gas off before any inspection."""

def pilot_triage(lights_while_held: bool,
                 dies_on_release: bool,
                 sensor_type: str,          # "thermocouple", "thermopile" or "unknown"
                 flame_hits_tip: bool,
                 probe_dirty: bool,
                 valve_connection_tight: bool) -> list[str]:
    steps = []
    if not lights_while_held:
        steps.append("Pilot won't light at all: this isn't a sensor problem. "
                     "Check gas supply and the pilot orifice, or call a pro.")
        return steps
    if not dies_on_release:
        steps.append("Pilot stays lit: the sensor is likely doing its job. Look elsewhere.")
        return steps
    if sensor_type == "unknown":
        steps.append("Identify the sensor first (part number on the old one, "
                     "or the appliance model number). Thermocouples and "
                     "thermopiles are not interchangeable.")
    if not flame_hits_tip:
        steps.append("Re-aim or clean the pilot so the flame wraps the probe tip.")
    if probe_dirty:
        steps.append("Clean soot or corrosion off the probe (gas off, cool).")
    if not valve_connection_tight:
        steps.append("Snug the connection at the gas valve: a loose fit drops voltage.")
    fixable = [x for x in steps if not x.startswith("Identify")]
    if not fixable:
        steps.append("If everything looks right, the sensor is probably worn. "
                     "Replace it with the same type, connection and equal or longer length.")
    return steps


if __name__ == "__main__":
    for s in pilot_triage(True, True, "thermocouple", True, False, True):
        print("-", s)

Running it with "lights, dies on release, thermocouple, flame on tip, clean, tight" prints one line: the sensor is probably worn, so replace it like for like.

Matching a replacement

When you do replace it, match three things: the type (thermocouple vs thermopile), the connection style (threaded nut vs spade terminals), and a tube that's the same length or a bit longer. Our pilot light troubleshooting guide goes deeper on each, with example part specs. If your furnace uses a hot surface igniter instead of a standing pilot, the furnace won't ignite guide is the better starting point.

When to call a pro

Call a licensed technician if you smell gas at any point, if the pilot won't light at all, if a new sensor doesn't fix it, or if you're not comfortable working near gas. A gas valve that won't hold with a good sensor needs professional service.

HVAC Fitter team. Not professional advice; follow your appliance manual and local codes.

Contactor Chatter on a Heat Pump: What to Check Before You Order Parts

HVAC Fitter — Fri, 06 Nov 2026 23:22:47 +0000

By the HVAC Fitter team. General information, not a substitute for your system's manual or a licensed tech when you cannot safely work on live power.

A heat pump that chatters is hard to ignore. The outdoor unit buzzes, the contactor armature chatters in and out, and the compressor may never settle into a clean start. The instinct is to order a new contactor. Sometimes that is right. Often it is not — and a new contactor that chatters for the same reason will fail just as fast.

Before buying parts: confirm supply under load, check the lugs, inspect the coil circuit, then look at the contacts.

What "chatter" usually means

A contactor is a relay. The thermostat (or control board) applies low-voltage coil power — usually 24 V on residential gear — and the coil pulls the armature closed so line voltage reaches the compressor and outdoor fan. Chatter is the armature bouncing because the magnetic pull cannot hold the contacts closed under load. That bounce arcs and pits the faces; pitted faces raise resistance and heat, which worsens the next cycle.

1. Supply voltage under load

A weak coil pull is often a voltage problem, not a bad coil. With the disconnect pulled and verified dead, measure safely once power is restored:

Coil voltage with the unit calling. Measure at the coil terminals while the thermostat is calling. Steady ~24 V (or the coil's rated voltage) is expected. A sag into the teens under call is a control-circuit or transformer problem — a new contactor will not fix it.
Line voltage under load. Measure L1–L2 (or L1–N on single-pole setups) while the compressor tries to start. A deep sag under start amp draw points at a loose lug, undersized conductor, weak disconnect, or a utility-side issue upstream.

If either reading collapses only when the unit tries to start, chase the supply first. A new coil on a soft 18 V control circuit will chatter just like the old one.

2. Loose lug or terminal

Loose power lugs are often misdiagnosed as a "bad contactor." With power locked out and verified, inspect every line and load lug for discoloration, heat marks, or a lug that turns with light torque. Check the outdoor disconnect and mounting screws — vibration loosens hardware over seasons. Confirm the coil control wires are tight and not oxidized. Retorque to the manufacturer's spec; if a lug or body is heat-damaged, replace it — do not reuse a melted lug on a new contactor.

3. Failing coil

When coil voltage is solid under call and the lugs are tight, the coil itself may be weak. Compare the printed coil voltage rating to what the control circuit delivers. Watch the armature: a coil that pulls in weakly, then drops out as compressor inrush hits, is often end-of-life — after you have ruled out supply sag. A burnt winding or cracked bobbin is a clear replace.

When you replace, match poles, coil volts, and amp rating (same or higher FLA/inductive rating). Our contactor replacement basics cover those three numbers and the safe swap sequence — lock out, pull the disconnect, and test for power before you touch anything. The capacitor next to the contactor can hold a charge too.

4. Pitted or burnt contacts

With power locked out, inspect the contact faces. Light gray oxidation is common. Deep pits, black cratering, or welded tips mean hard arcing — from chatter, a hard-starting compressor, or insects bridging the faces (ants are classic). Contacts stuck closed keep the outdoor unit running after the thermostat opens. Pitted contacts justify a replace — after you have ruled out low coil voltage and a loose line lug. Otherwise you are swapping the victim, not the cause.

Before you order

Work the list in order: (1) coil voltage under call — steady and on-spec? (2) line voltage under start — no deep sag? (3) lugs and control terminals — tight, no heat damage? (4) coil and contact faces — burnt, weak, or pitted?

If steps 1–3 fail, fix those first. If they pass and the contacts or coil look bad, replace and match the three numbers on the old label. For the outdoor unit model plate (corner panel where the copper lines enter), see how to find your model number.

Call a licensed HVAC tech if you cannot verify power is dead, if any conductor looks melted, or if a new contactor chatters or burns out quickly. A contactor that keeps failing often signals a larger electrical or compressor problem, not a parts lottery.

Written by the HVAC Fitter team (hvacfitter.com). Contactors carry line voltage — treat them that way.

Frost or a Frozen Heat Pump? Writing the Triage as a Small Python Function

HVAC Fitter — Thu, 05 Nov 2026 20:23:38 +0000

The first cold mornings of November bring the same question every year: the outdoor unit of a heat pump is white with frost. Is that normal, or is it broken?

The answer is a short decision list, and a decision list is easy to write as code. This post turns the checks from HVAC Fitter's heat pump iced up guide into a function you can read top to bottom. It's a toy for learning, not a repair tool.

The facts the code encodes

From the guide (updated Oct 22, 2026):

Light white frost is normal when it's near freezing outside. Moisture sticks to the cold coil, and the defrost cycle clears it.
Thick ice or a solid block is not normal. Airflow stops and heating drops fast.
During defrost, the unit briefly runs in cooling mode and the outdoor fan usually stops. So a still fan during defrost is expected. A fan that won't spin while heating is not.
A fan that hums but won't spin often points to a bad capacitor rather than a dead motor.
Ice that stays for days points to the defrost control board.
A clogged indoor filter can disrupt the cycle too. Most filters need changing every 1 to 3 months.
Refrigerant work needs an EPA Section 608 certified tech. That's always the last branch.

The function

from dataclasses import dataclass

@dataclass
class Observation:
    ice: str                   # "none", "light frost", "thick ice" or "solid block"
    hours_iced: float          # how long the ice has stayed
    outdoor_fan_spinning: bool # while the unit is heating (not during defrost)
    fan_hums: bool             # you hear a hum but the blades don't turn
    filter_age_months: float   # months since the indoor filter was changed

def triage(o: Observation) -> list[str]:
    steps = []
    if o.ice in ("none", "light frost"):
        return ["Normal. Light frost is standard near freezing; the defrost cycle clears it."]
    if o.filter_age_months >= 3:
        steps.append("Replace the indoor air filter (most need it every 1 to 3 months).")
    if not o.outdoor_fan_spinning:
        if o.fan_hums:
            steps.append("Fan hums but won't spin: suspect the run capacitor before the motor.")
        else:
            steps.append("Fan dead: check the motor; a replacement must match HP, volts and rotation.")
    if o.hours_iced >= 48:
        steps.append("Ice that stays for days: suspect the defrost control board.")
    steps.append("Still iced after that, or any refrigerant question: call a licensed tech.")
    return steps

if __name__ == "__main__":
    cases = {
        "frosty morning": Observation("light frost", 1, True, False, 1),
        "old filter":     Observation("thick ice", 6, True, False, 5),
        "humming fan":    Observation("thick ice", 30, False, True, 1),
        "solid block":    Observation("solid block", 48, True, False, 2),
    }
    for name, obs in cases.items():
        print(f"{name}:")
        for s in triage(obs):
            print("  -", s)

Output

frosty morning:
  - Normal. Light frost is standard near freezing; the defrost cycle clears it.
old filter:
  - Replace the indoor air filter (most need it every 1 to 3 months).
  - Still iced after that, or any refrigerant question: call a licensed tech.
humming fan:
  - Fan hums but won't spin: suspect the run capacitor before the motor.
  - Still iced after that, or any refrigerant question: call a licensed tech.
solid block:
  - Ice that stays for days: suspect the defrost control board.
  - Still iced after that, or any refrigerant question: call a licensed tech.

Why the order matters

The checks run cheapest-first. A filter costs a few dollars and takes a minute, so it comes before anything electrical. The "call a licensed tech" line is never skipped. Every frozen case ends there if the easy fixes don't work.

Two things the code doesn't try to do:

It doesn't tell you to open the unit. The guide's safety rules come first: power off at the breaker and the outdoor disconnect, test for power, and remember that a capacitor can hold a charge with the power off. If that isn't you, stop and call a pro.
It doesn't name a part. If the fan hums, the next step is reading the capacitor label and matching it. See which capacitor do I need. A replacement fan motor must match horsepower, voltage and rotation.

Try extending it

Add a defrost_running flag so a still fan during defrost returns "normal".
Return objects with a cost and needs_pro field, then sort by them.
Write tests for the four cases above with pytest.

If you'd rather check with a person than a function, the full guide has the thaw steps and the part lists: hvacfitter.com/guides/heat-pump-iced-up.

Why a furnace short cycles: a simple order of checks

HVAC Fitter — Sat, 31 Oct 2026 16:15:59 +0000

Short cycling means the furnace lights, runs for a few seconds or minutes, shuts off, and then tries again. The house never quite warms up, and the parts wear faster.

Most cases come down to three things: airflow, a safety control, or the thermostat. Here is the order I would check them in, cheapest first.

Safety first. Turn off power at the breaker or furnace switch before you open anything, and shut the gas valve before working near the burners. If you smell gas, leave the house and call the gas company from outside. Never bypass a limit switch, rollout switch or flame sensor.

1. The air filter

A clogged filter starves the furnace of air. The heat exchanger gets too hot, the high limit switch opens, and the burners shut off. A new filter of the right size is the first and cheapest fix. If the limit keeps tripping after that, this guide walks through the airflow checks: High limit switch keeps tripping.

2. The flame sensor

If the burners light and then go out after a few seconds, the flame sensor may not be "seeing" the flame. A thin coat of residue is enough. Often a gentle cleaning fixes it; sometimes a new sensor is the better choice: Flame sensor: clean it or replace it?

3. The thermostat

A thermostat in a drafty spot, near a supply vent, or with weak batteries can call for heat on and off. Check its spot and its settings before you buy parts.

When to stop and call a pro

If the filter is clean, the sensor is clean and the furnace still short cycles, or you see error codes you can't clear, call a licensed technician.

The full walkthrough, with what each symptom looks like, is here: Furnace short cycling: causes and fixes.

Written by the HVAC Fitter team.

16x25x1 Isn't 16 by 25: Parsing and Validating HVAC Air Filter Sizes in Python

HVAC Fitter — Mon, 26 Oct 2026 19:02:25 +0000

Measure a common furnace filter with a tape and you'll get about 15.5 by 24.5 inches, three-quarters of an inch thick. Nobody sells that size. The label on the frame says 16x25x1.

That little gap between the label and the tape is a nice, small data-modeling problem. If you build anything that matches parts (a store search, an inventory sheet, a home-maintenance app), you'll hit it. Here's a tiny Python model of the rules.

Written by the HVAC Fitter team (hvacfitter.com). General information, not a replacement for your system's manual.

The rules, in plain English

These come from our guide on how to size an air filter:

The size is printed on the frame of the old filter, like 16x25x1: length, width and depth, in inches.
The order of the first two numbers doesn't matter. A 16x25 and a 25x16 are the same filter.
The label is the nominal size, rounded up. A 16x25x1 really measures about 15.5 x 24.5 x 0.75 in, so it can slide into the slot.
No label? Measure it and round each number up to the next whole inch (or the next half inch for odd sizes).
Depth must match the slot. Filters come 1, 2, 4 and 5 in deep. Never force a thicker one in, and don't use a thin one in a deep slot, because air goes around it.

Rules 2, 3 and 5 are exactly the kind of thing a naive string match gets wrong.

Parsing a size string

People type sizes every way: 16x25x1, 25 X 16 x 1, 16*25*1. Normalize them into one canonical form, with the two face numbers sorted so order stops mattering.

import math
import re
from dataclasses import dataclass

VALID_DEPTHS = {1, 2, 4, 5}  # inches; the common furnace filter depths
SIZE_RE = re.compile(
    r"^\s*(\d+(?:\.\d+)?)\s*[x×X*]\s*(\d+(?:\.\d+)?)\s*[x×X*]\s*(\d+(?:\.\d+)?)\s*$"
)


@dataclass(frozen=True)
class FilterSize:
    a: float      # the smaller face dimension
    b: float      # the larger face dimension
    depth: float

    def __str__(self):
        f = lambda n: f"{n:g}"
        return f"{f(self.a)}x{f(self.b)}x{f(self.depth)}"


def parse_size(text: str) -> FilterSize:
    """Parse '16x25x1', '25 X 16 x 1' or '16*25*1' into one canonical size."""
    m = SIZE_RE.match(text)
    if not m:
        raise ValueError(f"not a filter size: {text!r}")
    w, l, d = (float(g) for g in m.groups())
    a, b = sorted((w, l))  # 16x25 and 25x16 are the same filter
    return FilterSize(a, b, d)

Sorting the face dimensions is the whole trick for rule 2. Now parse_size("25 X 16 x 1") and parse_size("16x25x1") are equal, because frozen dataclasses compare by value.

From a tape measure to a label size

Rule 3 and 4 in code: round each measured number up.


def nominal_from_measured(w: float, l: float, d: float) -> FilterSize:
    """Measured frame (e.g. 15.5 x 24.5 x 0.75) -> the size printed on the label."""
    up = lambda n: float(math.ceil(n - 1e-9))
    return FilterSize(*sorted((up(w), up(l))), up(d))

The - 1e-9 keeps a measured 16.0 from turning into 17 when float math leaves it at 16.0000000001. This version only rounds to whole inches. If you need the "next half inch for odd sizes" case, round to math.ceil(n * 2) / 2 and check the result against a list of sizes you actually stock.

Checking a swap

Most real bugs show up when someone swaps one filter for another. Compare the face sizes and the depth separately, so the error message says what is wrong.


def check_swap(old: str, new: str) -> list[str]:
    """Return problems with replacing filter `old` by filter `new` (empty = fine)."""
    o, n = parse_size(old), parse_size(new)
    problems = []
    if (o.a, o.b) != (n.a, n.b):
        problems.append(f"face size differs: {o.a:g}x{o.b:g} vs {n.a:g}x{n.b:g}")
    if o.depth != n.depth:
        why = ("too thick, it won't fit the slot" if n.depth > o.depth
               else "too thin, air will go around it")
        problems.append(f"depth {n.depth:g} in vs slot {o.depth:g} in: {why}")
    if n.depth not in VALID_DEPTHS:
        problems.append(f"unusual depth {n.depth:g} in; check the slot")
    return problems


if __name__ == "__main__":
    assert str(parse_size("25 X 16 x 1")) == "16x25x1"
    assert str(nominal_from_measured(15.5, 24.5, 0.75)) == "16x25x1"
    assert check_swap("16x25x1", "25x16x1") == []
    print(check_swap("16x25x4", "16x25x1"))
    print(check_swap("16x25x1", "16x20x1"))

Running it:

['depth 1 in vs slot 4 in: too thin, air will go around it']
['face size differs: 16x25 vs 16x20']

The first case is an easy mistake: the slot takes a 4-inch filter, someone grabs a 1-inch one because the face size matches. The face check passes, the depth check catches it.

Why not just store the string?

Because three different strings mean the same filter, and one string (16x25x1) means a frame that measures something else. If your search index stores the raw label text, "25x16x1" returns nothing, and a customer with a tape measure never finds a match. Store the canonical form, and search on it.

The same idea works for part numbers. A 4-inch filter marked CF100A1009 has a set of replacements, which is a lookup table problem, not a parsing problem. See the CF100A1009 replacement page for one example.

A few edge cases worth a test

16 x 25 x 1" with an inch mark: strip " and in before matching.
Metric labels: some filters print both. Keep the inch size as the key.
MERV rating: it isn't part of the size. Many homes use MERV 8 to 11, and a higher MERV can slow airflow on some systems, so keep it as a separate field.

That's the whole model: one regex, one sort, one round-up and two comparisons. If you want to see it used on real stock, our air filter listings are filtered by the numbers printed on the old frame.

Turn the system off before you swap a filter, and point the airflow arrow toward the furnace or air handler.

Modeling "will this part fit?" as code: a replacement-rule validator for HVAC capacitors

HVAC Fitter — Fri, 23 Oct 2026 17:05:31 +0000

Most "does this part fit?" questions in e-commerce get answered with a lookup table: part A replaces part B because somebody typed it into a spreadsheet. That breaks down for commodity electrical parts, where thousands of part numbers are really just a handful of ratings. For those, it's better to encode the substitution rules and check any candidate against the original part.

Run capacitors in air conditioners and heat pumps are a clean example. The label on the old part tells you nearly everything you need, and the rules for a safe replacement are short:

Capacitance (µF, also printed MFD) must match exactly. A dual-run label like 45 + 5 MFD means 45 µF for the compressor (HERM) and 5 µF for the fan. The tolerance printed next to it (±5% or ±6%) is the normal manufacturing range. It doesn't let you pick a different size.
Voltage must be the same or higher. A 440 V part can replace a 370 V part. A 370 V part can never replace a 440 V one.
Type must match. Dual run (three terminals: HERM, FAN, C), single run (two terminals) and start capacitors (rated as a range, like 88 to 108 µF) aren't interchangeable.
Shape doesn't matter electrically. Round vs oval is only a fit-in-the-bracket question.

Here's that as a tiny validator:

from dataclasses import dataclass

@dataclass(frozen=True)
class Capacitor:
    kind: str            # "dual_run", "single_run" or "start"
    uf: tuple            # (45, 5) for dual, (10,) for single
    volts: int           # 370 or 440, typically
    shape: str = "round"

def can_replace(original: Capacitor, candidate: Capacitor) -> list[str]:
    """Return a list of problems. An empty list means it's a valid substitute."""
    problems = []
    if candidate.kind != original.kind:
        problems.append(f"type mismatch: {candidate.kind} vs {original.kind}")
    if candidate.uf != original.uf:
        problems.append(f"µF must match exactly: {candidate.uf} vs {original.uf}")
    if candidate.volts < original.volts:
        problems.append(f"voltage too low: {candidate.volts} V < {original.volts} V")
    if candidate.shape != original.shape:
        problems.append("note: different shape, check the mounting bracket")
    return problems

old = Capacitor("dual_run", (45, 5), 370)
print(can_replace(old, Capacitor("dual_run", (45, 5), 440)))   # []
print(can_replace(old, Capacitor("dual_run", (40, 5), 440)))   # µF mismatch
print(can_replace(Capacitor("dual_run", (45, 5), 440),
                  Capacitor("dual_run", (45, 5), 370)))        # voltage too low

A few design notes from building this kind of check:

Return reasons, not a boolean. "Doesn't fit" is useless to a customer. "Voltage too low" teaches them the rule.
Separate hard failures from warnings. Shape is a warning. µF and voltage are hard stops.
Parse the label, not the part number. Many brands print the same ratings under different numbers. Normalizing 45/5, 45+5 and 45 + 5 MFD into one tuple does most of the work.
Never let tolerance leak into matching. It's tempting to treat ±6% as a fuzzy-match window. Don't.

If you want the plain-English version of these rules (with label photos and the safety steps, because a capacitor can hold a charge with the power off), the HVAC Fitter capacitor guide is where I took them from. A worked example of one rating is the 45/5 MFD dual run capacitor spec page.

The same pattern works for contactors (coil voltage and amps), transformers (VA and volts) and air filters (nominal size). Encode the rule once and every new part number is just data.

Safety note: this is about data modeling. If you're replacing a capacitor yourself, turn off power at the breaker and the outdoor disconnect and discharge the capacitor first, or call a licensed HVAC technician.