The Formater Tools Blog

Practical, specific write-ups on the data formats behind our tools - JSON, JWT, Base64, UUIDs, YAML - and the details that actually trip people up when working with them.

No fluff, no "10 tips" filler. Each post digs into one real problem, shows a worked example, and links to the tool where you'd actually go to solve it.

JSON Syntax Errors, Explained: How to Read Them and Fix Them Fast

Why JSON parsers are so strict, how to actually read a "position 47" error, and the two mistakes that cause most broken JSON.

What's Actually Inside a JWT (and Why Decoding Isn't the Same as Verifying)

The three-part structure, what's really in the header and payload, and why anyone can read or forge a token's contents without ever touching the secret.

Base64 Isn't Encryption: What It's Actually For

What base64 really does, why anyone can reverse it in one line of code, and the legitimate jobs it's good at - plus the 33% size tax nobody mentions.

UUID v1 vs v4: Which One Should You Actually Use?

What a UUID actually guarantees, how v1 and v4 are built under the hood, and a specific caveat about the UUID generator on this site worth knowing before you rely on it.

YAML vs JSON for Config Files: The Real Trade-offs

Comments and anchors versus strict unambiguous structure, the indentation gotcha that breaks pipelines silently, and when each format actually wins.

MD5 vs SHA-256: What Hashing Actually Proves (and Doesn't)

Why MD5 and SHA-1 are "broken" specifically for collisions but still fine for checksums, and why hashing a password directly is still the wrong move.

What Actually Makes a Password Strong (It's Not What You Think)

Password strength as bits of entropy, worked-out math on a real 16-character example, and why symbol substitutions barely help against modern cracking.

Greedy vs Lazy Regex: The Quantifier Mistake Everyone Makes Once

Why greedy quantifiers grab more than you expect, how lazy quantifiers fix it, and the unescaped-dot mistake that trips up almost every beginner.

Unix Timestamps Explained: Seconds, Milliseconds, and the Year 2038 Problem

What a timestamp actually counts, why mixing up seconds and milliseconds produces wildly wrong dates, and why 2038 is still a real legacy risk.

What Minification Actually Does to Your Code (and What It Doesn't)

What minifiers really strip versus what they leave untouched, why it isn't compression or obfuscation, and a real bug in this site's own JS minifier.

Why WordPress Still Uses PHP's Serialize Format in 2026

Why wp_options and postmeta are still stuck with PHP's serialize format, and why a naive find-and-replace during a domain migration corrupts it.