Implementation guides
Practical guides for reference data and developer workflows
Practical checks for phone, ID-format, and locale references, plus JSON, JWT, URL, time, password, and Open Graph workflows.
Reference data
Phone number formatting for test data
Use country format references safely without generating callable test phone numbers.
Use ID format references safely
Why a public ID-format reference is not an identity validator or generator.
Language and locale codes by country
Choose BCP 47 locale tags without confusing language, territory, and script.
Developer workflows
CSV to JSON: preserve text and fix ambiguous rows
Keep leading zeros and long identifiers intact, understand CSV quoting, and resolve duplicate headers, missing cells and UTF-8 errors before converting.
Gzip, zlib and raw DEFLATE: containers, bytes and safe local previews
Choose the correct compressed container, understand Base64 and HTTP decoding, and preserve binary output within native browser and resource limits.
UUID versions, encoded timestamps and privacy
Read UUID versions and variants, compare v1 / v6 / v7 timestamps and understand what decoded fields cannot prove before exporting identifiers.
CSS image filters: order, scope and safe previews
Understand filter order, neutral values, blur overflow and local image limits before using generated CSS. Blur is not redaction.
CSS 2D transforms: order, origin and reference boxes
Compare translate and rotate order, percentage reference boxes, transform-origin and singular scales before copying native CSS transforms.
CSS text shadows: layers, overflow and readable text
Understand text-shadow order, inheritance, painted overflow and forced colors, then check the editor's eight-layer limits against real text.
CSS border-radius: elliptical corners and overlap
Understand clockwise corner order, slash-separated radii, percentage sizing and the browser's overlap reduction before copying border-radius CSS.
CSS clip-path polygon: coordinates, clipping and focus
Understand polygon point order, percentage coordinates, aspect ratios, native fill rules and focus clipping before using generated clip-path CSS.
CSS box-shadow: layers, inset shadows and clipping
Understand box-shadow layer order, negative spread, inset rendering and overflow clipping before using generated CSS in your interface.
CSS gradient stops, hard edges and text contrast
Read linear and radial gradient stops correctly, create intentional hard edges, and check text contrast in the rendered layout.
Flexbox sizing, wrapping and source order
Understand Flexbox axes, item sizing and wrapping before copying a generated layout into your project.
CSS Grid areas: visual layout, tracks and source order
Build rectangular grid-template-areas, understand track sizing, and check HTML reading order before using generated CSS.
CSS easing: control points, overshoot and reduced motion
Read cubic-bezier() coordinates, compare easing at the same duration, and respect reduced-motion preferences in the component you ship.
Fluid typography with CSS clamp(): formula and accessibility
Check fluid font-size endpoints, root rem assumptions, browser support and 200% text resizing before shipping clamp() CSS.
XML formatting: well-formedness, whitespace and validation
Understand what an XML syntax check proves, why whitespace can matter, and when to use an XSD validator instead.
Turn JSON into TypeScript without trusting the sample
Use a JSON sample to start a TypeScript contract while keeping runtime checks separate.
Inspect JWT claims without treating them as proof
Read JWT metadata locally for debugging while keeping signature verification and authorization separate.
URL encoding: encode data, not the whole address
Inspect URL components locally and avoid double-encoding query values or paths.
Convert timestamps without losing the time zone
Preserve an instant, name the source time zone, and handle daylight-saving gaps explicitly.
Generate passwords locally, then protect them properly
Use unique random passwords and keep generation separate from storage, recovery, and server-side hashing.
Validate Open Graph metadata before sharing a page
Build escaped social metadata locally and check that canonical URLs, titles, and descriptions tell one story.
Read a text diff without mistaking noise for change
Compare two text revisions locally, handle whitespace deliberately, and know when a diff is not enough.
Cronie schedules: day fields, DST, and step values
Read a five-field Cronie schedule without confusing it with other cron dialects or deployment proof.
WCAG color contrast: read ratios without overclaiming
Apply WCAG 2.2 text and non-text contrast thresholds, understand large text, and know what a two-color ratio cannot prove.
HTML escaping: encode for the destination context
Encode HTML text and quoted attributes without confusing character references with sanitization, JavaScript, CSS, or URL safety.
Unix file permissions: read chmod modes without guessing
Convert Unix permission modes, distinguish files from directories, and review special bits without treating a calculator as an access decision.
Intl plural rules and visible decimals
Compare cardinal and ordinal categories, JavaScript default rounding and visible fraction digits across locales using Intl.PluralRules.
i18n JSON key parity: exact paths and translation boundaries
Check missing translation keys without conflating literal dots with nested JSON, and understand blank values, plural and fallback exceptions, placeholders and private reports.
JSON Pointer, JSON Patch and Merge Patch: paths and safe changes
Distinguish exact JSON paths from queries, choose an atomic patch format and preserve null, empty keys and numeric precision when exporting local data.
CSV workflows: preserve strings, join tables, compare keys and export SQL
Preserve CSV identifiers, join tables with unique lookup keys, compare revisions and understand spreadsheet formula risks and PostgreSQL export limits.
Data redaction and .env comparison: what masking cannot prove
Compare environment keys without exporting values, then review JSON path suggestions and choose which values to mask.
JSON flattening: paths, collisions and reversible data
Understand the fixed dot/bracket path convention, preserve empty containers and reject ambiguous keys, sparse arrays and precision loss before flattening JSON.
Intl number formatting: precision, locale defaults and invisible separators
Keep decimal input exact, distinguish display rounding from arithmetic, and inspect currency defaults, locale resolution and Unicode separators before copying Intl.NumberFormat code.
Unicode normalization, hidden characters and text encoding
Separate bytes from Unicode text, compare canonical and compatibility normalization, and inspect invisible characters without destroying intentional language or emoji content.
Calendar dates, ISO week years and elapsed durations
Choose civil-date arithmetic instead of timestamp subtraction, understand ISO week-year boundaries and keep signed durations separate from clock times.
Single-event ICS files: UTC, all-day dates and safe text
Generate one iCalendar event with explicit UTC times or exclusive all-day end dates, then check UTF-8 folding, escaped content and calendar-app import behavior.
Exponential backoff and jitter: retry timing and deadline boundaries
Model retry waits and start-time ranges with capped exponential backoff, jitter, Retry-After and an optional deadline.
HTTP Range and Content-Range: exact bytes, 206, 416 and safe resume boundaries
Understand inclusive byte offsets, suffix ranges, encoded representations and If-Range before interpreting a partial download. Distinguish offline models from real server behavior.
HTTP headers: cache policy, duplicate fields and download filenames
Read header blocks without merging Set-Cookie, distinguish cache validation from storage, and generate quoted ASCII and UTF-8 download filenames safely.
CSP and CORS: different browser boundaries, not security certificates
Separate content-source policy from cross-origin response sharing, understand nonce and preflight requirements, and verify deployed behavior without weakening safeguards.
robots.txt, XML sitemaps and hreflang: separate SEO contracts
Distinguish crawl permissions, URL discovery and localized alternates, then check XML and language mappings without mistaking offline syntax checks for indexing proof.
JSON-LD: truthful structured data and safe script integration
Choose Article, BreadcrumbList or WebSite deliberately, keep markup consistent with visible content, and distinguish valid JSON from safe embedding and rich-result eligibility.
Android App Links: prepare and publish assetlinks.json
Prepare an Android Digital Asset Links statement, preserve existing associations, and verify the deployed configuration on Android.
iOS Universal Links: publish and troubleshoot an AASA file
Publish apple-app-site-association over HTTPS, configure Associated Domains in Xcode, and diagnose paths that still open in the browser.
Cookie and HAR inspection: keep credentials out of shared reports
Separate Cookie from Set-Cookie, read missing network timing honestly, and inspect a local HAR without replaying requests or sharing raw secrets.
URI templates: expansion, encoding and destination boundaries
Understand RFC 6570 operators, empty and missing variables, lists and maps, without confusing template expansion with a trusted URL or a network request.
IPv6, CIDR and IANA: exact ranges are not routing or service proof
Read IPv6 notation, exact CIDR set operations and dated IANA special-address and port registries without widening policies or inferring live reachability.
DNS records: zone-file syntax, TXT bytes and publication checks
Build A, AAAA, CNAME, MX, TXT, NS, PTR, CAA and SRV records, distinguish zone-file text from provider forms and verify deployment separately.
Documentation tables: escaping, captions and readable headers
Turn CSV into simple Markdown or HTML data tables without executing cell markup, losing textual values or hiding the table's structure from assistive technology.
Local images: pixel differences, cropping and export limits
Compare decoded pixels without silent resizing, choose crop and JPEG backgrounds explicitly, and understand native encoding and sampled palettes.
PWA icons: a circular maskable safe zone is not installability
Fit artwork into the maskable 40%-radius circle, export ordinary and maskable PNGs and publish a customized manifest without claiming installability.
SVG paths: command endpoints and approximate native geometry
Read path d commands, relative coordinates and arc flags, and distinguish browser-estimated path length from exact geometry and stroke bounds.
CSS inspection and layout: inert selectors, scroll snap and columns
Test selectors without executing HTML, distinguish snapport insets from element spacing and check multi-column reading order on narrow screens.
CSS color-mix: independent percentages, alpha and native support
Understand missing percentages and normalization, compare native color spaces and distinguish a browser swatch from contrast or appearance guarantees.
ULID timestamps: Crockford encoding, ordering and privacy
Decode exact ULID milliseconds, distinguish Crockford Base32 from RFC 4648 and understand padding, overflow, batch errors and what sortable identifiers cannot prove.
Hex bytes: offsets, exclusive ranges and byte order
Read binary data without changing it, distinguish printable ASCII from UTF-8, inspect exact integers and export byte ranges with explicit local resource limits.
Base32: choose an alphabet and preserve canonical padding
Distinguish RFC 4648 Base32 from base32hex, understand unused bits and inspect non-UTF-8 bytes without treating encoding as encryption.
IEEE 754: exact stored decimals, direct rounding and neighbors
Read binary32 and binary64 fields, avoid decimal-to-double-to-float double rounding and distinguish NaN, signed zero and subnormal values.
Bitwise operations: explicit width, signed ranges and full-width shifts
Keep integers exact up to 128 bits, separate accepted input ranges from output interpretation and understand masks, sign fill and rotations.
Protobuf wire data: boundaries are not a schema
Read tags, uint64 varints and fixed-width byte ranges while keeping length-delimited bytes distinct from guessed strings or nested messages.
SSH public keys: wire structure, SHA256 fingerprints and trust
Inspect supported OpenSSH public-key fields, compare a digest of the original blob and understand why a fingerprint cannot identify an owner.
Read OpenAPI locally without hiding unresolved references
Trace operation inheritance and bounded JSON references before exporting an OpenAPI summary.
Convert cURL to code: bodies and runtime boundaries
Convert static commands to Fetch or server-side code while reviewing body, header, redirect and runtime limits.
Convert subtitle timing while making WebVTT loss explicit
Choose SRT or WebVTT, shift integer milliseconds without clamping and review cue IDs, settings, ordering and overlaps.
Create vCard 4.0 with correct UTF-8 folding and contact privacy
Distinguish contact serialization from verification, escape TEXT safely and fold by octets rather than JavaScript string length.
Read geohash cells without claiming location accuracy
Understand longitude-first bisection, exact degree bounds, center points, antimeridian wrapping and absent polar neighbors.
Read SSE captures without inventing missing events
Understand blank-line dispatch, multiline data, inherited IDs, retry state and the limits of offline Server-Sent Events captures.
Browser DNS, IP and HTTP requests: consent, CORS and privacy
Review exactly where an explicit network request goes, what the destination sees and why a browser-visible response is not a server or security certificate.
Local format tools: preserve meaning, reject unsafe execution
Distinguish formatting, minification, schema validation and data-model conversion before copying JSONPath, HTML, XML, CSS, JavaScript or SVG results.
Text estimates, redaction and browser timers: practical limits
Use readable estimates, explicit redaction rules and local timers without mistaking heuristics for anonymization, identity checks or reliable background alarms.