Last month a customer pasted a renewal date into our billing portal, and the backend saved 2026-01-31\n — trailing newline included — straight into a Postgres date column. The nightly import job died at 2 a.m. with invalid input syntax for type date: "2026-01-31\n".
The strange part: my validator used ^\d{4}-\d{2}-\d{2}$, and CI was green. It took me an embarrassing hour to work out why a “fully anchored” pattern let that string through. Since then I debug regexes with a fixed routine: one probe script, one cross-runtime check, and a free online regex tester for the times I don’t want to open an editor at all. Here’s the routine.
The first move is to stop guessing and print what the pattern actually does. Nothing fancy, just the standard library:
# probe.py — Python 3.11.1, standard library only
import re
PATTERN = r"^\d{4}-\d{2}-\d{2}$"
samples = ["2026-01-31", "2026-01-31\n", "2026-1-31", "x2026-01-31"]
for s in samples:
m = re.match(PATTERN, s)
f = re.fullmatch(PATTERN, s)
print(f"{s!r:18} match: {bool(m)!s:5} fullmatch: {bool(f)}")
Output on my machine:
'2026-01-31' match: True fullmatch: True
'2026-01-31\n' match: True fullmatch: False
'2026-1-31' match: False fullmatch: False
'x2026-01-31' match: False fullmatch: False
There it is. re.match with $ happily accepts the trailing newline, because $ also matches just before a final newline — a Perl inheritance documented in the Python re module docs. re.fullmatch is the honest one. Fifteen lines of probing beat an hour of staring at the pattern.
Our portal’s client-side validation is JavaScript, so the “same” pattern lives there too. I ported the probe:
// probe.mjs — Node 22.13.1
const PATTERN = /^\d{4}-\d{2}-\d{2}$/;
const samples = ["2026-01-31", "2026-01-31\n", "2026-1-31", "x2026-01-31"];
for (const s of samples) {
console.log(JSON.stringify(s).padEnd(18), "test:", PATTERN.test(s));
}
'2026-01-31' test: true
'2026-01-31\n' test: false
'2026-1-31' test: false
'x2026-01-31' test: false
A different answer for the newline case. In JavaScript, $ without the m flag matches only at the very end of the string — the semantics are spelled out on the MDN RegExp page. So my Python server accepted 2026-01-31\n while my JS client would have rejected it. The only reason the bad value got through was that the client-side check had been commented out during a refactor.
Two “equivalent” regexes, two answers. I now treat every ported pattern as guilty until probed in both runtimes.
Sometimes the fix is obvious and I only need to confirm one thing: does this pattern match this string, with these flags? Opening an editor for that is overkill. Pasting the pattern and the suspect input into this browser-based tool answers it in seconds. You see the match highlighted in the sample text and its exact position, and flipping a flag like m or i takes one click instead of a re-run.
It also handles the awkward cases where pasting matters. Customer data never leaves my machine because everything runs client-side, which turned out to matter more than I expected once I started doing this at work with real order IDs. And when I’m weighing two candidate fixes side by side, I keep both patterns in adjacent tabs of the regex testing tool and eyeball the highlighting — terminal output has never made that comparison as obvious for me.
1. $ is not “end of string” in Python. As shown above, re.match(r"^\d{4}$", "2026\n") returns a match. Use re.fullmatch instead, or anchor with \Z if you must — though Python 3.14 deprecates \Z, so fullmatch is the future-proof choice. JavaScript has no such surprise without the m flag, which is exactly why the two runtimes disagree.
2. Escapes copied from config files. My validation patterns live in a JSON config, and one wrong level of escaping blows up Python at import time:
Traceback (most recent call last):
File "validate.py", line 12, in <module>
PATTERN = re.compile(cfg["pattern"])
re.error: bad escape \m at position 5
Node is quieter about the same mistake: new RegExp("\\m") does not throw — it silently treats \m as a literal m. Only the u flag turns it into SyntaxError: Invalid regular expression: /\m/u: Invalid escape. So the JS port “worked” while matching something completely different. Rule of thumb: compile config-driven patterns at startup, never at request time.
3. Catastrophic backtracking. A colleague once merged two rules into ^(\d+)+$ — nested quantifiers, the classic ReDoS shape. Against a 31-character non-match like "1111111111111111111111111111111x", Python 3.11 spun for over 90 seconds before I killed the process; Node froze the same way. The re module gained atomic groups and possessive quantifiers in 3.11, so ^\d++$ or (?>\d+)+$ collapses the pathological path. If a validation endpoint hits 100% CPU with no traffic spike, look at the newest regex first.
| Situation | Tool |
|---|---|
| Production accepted garbage, need the exact match | Python probe: fullmatch + repr output |
| Pattern exists in two runtimes, results differ | Node probe, compare line by line |
| Quick “does this match?” while writing the pattern | Browser regex tester |
| CPU spike with no matching traffic | Hunt for nested quantifiers first |
The probe script lives in my snippets folder and earns its keep weekly. The browser tool covers everything in between — no install, no editor, no excuse for shipping an untested pattern again.
More free browser-based utilities at utilvy.com.