Guides & Tutorials
Practical, privacy-first developer guides — using free tools that run entirely in your browser.
How AI Text Detectors Work: Methods, Accuracy, and Limitations
AI text detectors use burstiness, perplexity, and phrase patterns to estimate if content was AI-generated — but no detector is definitive. Here's how they actually work.
How to Calculate Your Freelance Rate (The Complete Formula)
Most freelancers underprice by ignoring taxes, expenses, and non-billable hours. This complete formula accounts for all three — and explains why your billable rate must be higher than you think.
The True Cost of Your Meetings (And How to Reduce It)
A 1-hour meeting with 8 engineers costs more than most people realize. Learn how to calculate meeting ROI, when to use async instead, and which frameworks cut meeting time in half.
Heart Rate Training Zones Explained: From Fat Burn to VO2 Max
Understanding your 5 heart rate training zones helps you train smarter, not harder. Learn the Karvonen formula, what happens in each zone, and how to build an effective weekly training plan.
JSON Schema, Joi, Mongoose, and Zod: Which Validator Should You Use?
Choosing between Joi, Zod, Mongoose schemas, and JSON Schema? This guide explains when each validation approach fits best, with practical code examples for the most common patterns.
OpenAPI to TypeScript: Auto-Generate Types from Your API Spec
Stop writing API types by hand. Learn how to generate TypeScript interfaces directly from OpenAPI 3.0 specs — and keep them in sync automatically.
Schema.org Markup: The Complete Guide to Rich Results in 2026
Structured data can earn you rich results in Google Search — product ratings, FAQ dropdowns, recipe cards, and more. Here's how to implement every major schema type.
Regular Expressions Explained: From Basics to Advanced Patterns
Regex intimidates most developers, but it doesn't have to. This guide breaks down every major pattern with practical examples you'll actually use.
CSS Color Systems: HSL, oklch, and Building a Design Token Palette
Moving beyond hex codes is one of the best upgrades you can make to your CSS. Here's how HSL, oklch, and design tokens work together for maintainable color systems.
10 Financial Calculations Every Developer Should Know How to Build
From compound interest to mortgage amortization, financial calculators are among the most-used tools on the web. Here's the math behind the ones that matter most.
Debt Snowball vs Avalanche: The Math and Psychology of Paying Off Debt
The snowball method feels good. The avalanche saves the most money. Here's the math on both strategies — and why the one that works is the one you'll stick with.
Blood Pressure Numbers Explained: What Systolic, Diastolic, and MAP Really Mean
Blood pressure readings are two numbers that tell a detailed story about your cardiovascular health. This guide explains what each number means, the stages of hypertension, and evidence-based ways to lower yours.
Heart Rate Zones, FTP, and 1RM: The Fitness Metrics That Actually Matter
Most fitness apps track steps. This guide goes deeper — heart rate training zones, functional threshold power for cyclists, and strength percentages for weightlifters.
Git Branch Naming, Commit Messages, and Workflow Conventions That Scale
Good Git hygiene is invisible when it works and painful when it doesn't. Here's what actually matters in branch naming, commit conventions, and team workflow.
README, CONTRIBUTING, and License: The Open Source Documentation Checklist
A project without good documentation is invisible. This guide walks through every file your open source project needs — from the first README to the CONTRIBUTING guide.
Email Subject Lines That Get Opened: Data, Psychology, and Common Mistakes
Your email's subject line determines whether it gets opened or ignored. Here's what the research says about length, power words, personalization, and spam filters.
Prisma, Drizzle, TypeORM, Mongoose: Choosing the Right ORM for Your Stack
ORMs abstract database access, but each has different trade-offs in type safety, performance, and developer experience. Here's how to choose between the major options.
JSON, YAML, TOML, HCL, and When to Use Each Configuration Format
Every project has config files, and every team has opinions about formats. Here's a practical comparison of JSON, YAML, TOML, and HCL — when each shines and where each fails.
Core Web Vitals in 2026: LCP, INP, CLS and How to Actually Fix Them
Google's ranking signals are built on Core Web Vitals. Here's what each metric measures, what commonly causes failures, and the most effective fixes for each.
Freelance Developer Finances: Rates, Invoices, Taxes, and the Numbers You Need to Know
Most freelancers set their rate once and never revisit it. This guide walks through the actual math of sustainable freelance pricing — including taxes, non-billable time, and client-facing rates.
Complex Numbers Explained: From i to Fourier Transforms
Complex numbers appear in signal processing, quantum mechanics, and electrical engineering. Here's an approachable explanation of the math — from basic arithmetic to polar form.
Descriptive Statistics Every Developer Should Know: Mean, Median, Regression, and More
Most developers learn statistics on the job, usually when it's urgent. This guide covers the descriptive statistics that actually come up in real data analysis work.
Character Limits, Hashtags, and Algorithms: A Developer's Guide to Social Media Content
Social media platforms have wildly different technical constraints. This guide covers the character limits, image sizes, and optimization tips that matter for each major platform.
The 50/30/20 Budget Rule: How to Actually Build a Budget That Sticks
Most budgets fail because they're too complicated or too strict. The 50/30/20 rule is simple enough to follow but structured enough to make real progress on savings and debt.
Terraform HCL Explained: Blocks, Arguments, Expressions, and Common Patterns
HashiCorp Configuration Language powers Terraform infrastructure-as-code. This guide explains HCL syntax, block types, expressions, and the patterns you'll use in every Terraform project.
CSS Flexbox: The Complete Guide to Flexible Layouts
Master CSS Flexbox — flex-direction, justify-content, align-items, flex-grow, gap — with real layout examples for nav bars, card grids, and centering.
CSS Grid: The Complete Guide to Two-Dimensional Layouts
Learn CSS Grid from scratch — grid-template-columns, fr units, auto-fill, minmax, named areas — with real examples for holy grail, magazine, and responsive card layouts.
CSS Animations and Transitions: A Practical Guide
Build smooth hover effects and keyframe animations with CSS — transition properties, @keyframes, performance tips (GPU-accelerated properties), and prefers-reduced-motion.
Dates and Timestamps in JavaScript: A Developer's Guide
Avoid common Date pitfalls — Unix timestamps, Intl.DateTimeFormat, IANA timezones, ISO 8601, and the hidden UTC vs local parsing trap in new Date().
How QR Codes Work and How to Generate Them Online
Understand QR code structure — finder patterns, error correction levels, encoding modes — and best practices for URLs, WiFi, and vCard generation.
Cron Expressions Explained: Syntax, Examples, and Tips
Decode the 5-field cron syntax — minute, hour, day, month, weekday — with annotated examples for common schedules, special characters, and GitHub Actions cron.
HTTP Status Codes: A Developer's Complete Reference
Every HTTP status code class explained with REST API design guidance — when to use 201 vs 200, 401 vs 403, 301 vs 302, and common mistakes to avoid.
Markdown Syntax Guide: Formatting from Basics to Advanced
A complete Markdown reference — headings, bold, links, images, tables, fenced code blocks, task lists, and GFM vs CommonMark differences.
SEO Meta Tags Explained: Title, Description, and Open Graph
Write title tags, meta descriptions, canonical links, and Open Graph tags that improve rankings and social sharing — with optimal lengths and common mistakes.
CSS Units Explained: px, rem, em, vw, vh, and When to Use Each
Know when to use px, rem, em, vw, vh — including the em compounding trap, rem for accessibility, svh/dvh for mobile, and fluid typography with clamp().
Encryption vs Hashing: What's the Difference and When to Use Each
Encryption is reversible; hashing is not — understand when to use each, why MD5/SHA-1 fail for passwords, how salting works, and what HMAC adds.
Image Formats for the Web: JPEG, PNG, WebP, and SVG Compared
Choose the right image format — when to use JPEG, PNG, WebP, SVG, or AVIF — with a decision guide, Core Web Vitals impact, and picture element fallback patterns.
CAGR Explained: What It Is, the Formula, and How to Use It
What Compound Annual Growth Rate is, how to calculate it from start/end values and years, why it differs from average return, and when to use CAGR vs IRR.
SPF, DKIM, and DMARC Explained: Email Authentication for Developers
How SPF, DKIM, and DMARC work together to prove email legitimacy, stop spoofing, and protect your domain — with record syntax, common mistakes, and a step-by-step setup guide.
Network Speed Units Explained: Mbps, MB/s, Gbps, and More
Demystify internet and storage speed units — bits vs bytes, Kbps/Mbps/Gbps, why your 100 Mbps plan downloads at ~12 MB/s, and how bandwidth affects real-world transfer times.
Runtime Type Validation with Zod: A Practical Guide
Why TypeScript types alone aren't enough at runtime, how Zod validates API responses and environment variables, and how to generate a Zod schema from existing JSON.
Classic Ciphers Explained: Caesar, Atbash, Vigenère, and Polybius
How historical substitution ciphers work — Caesar shift, Atbash mirror, Vigenère key, and the Polybius square — with the math behind each and why they're insecure today.
HTTP Security Headers Explained: CSP, Cookies, and Robots
A practical guide to the HTTP security headers every web app should set — Content-Security-Policy, Set-Cookie flags, X-Robots-Tag, and CORS — with generator tools for each.
IP Addressing Explained: Decimal, Binary, Hex, and Subnets
How IP addresses work in every number base — dotted decimal, binary octets, and hexadecimal — plus CIDR subnet masks, private ranges, and loopback addresses explained simply.
Fraction Arithmetic: Add, Subtract, Multiply, and Divide Step by Step
How to add, subtract, multiply, and divide fractions — finding the lowest common denominator, simplifying with GCD, and handling mixed numbers — with worked examples.
CSS Resets vs Normalize: Which Reset Should You Use in 2026?
Comparing CSS reset strategies — Eric Meyer Reset, Normalize.css, the modern minimal reset, and Tailwind Preflight — when to use each, and what they actually change in the browser.
CSS Gradients: Linear, Radial, and Conic — A Complete Guide
Master CSS gradients — linear, radial, and conic — with syntax breakdowns, multi-stop techniques, animation tips, and a free in-browser gradient generator.
JavaScript Regex Flags Explained: g, i, m, s, u, y, d
A practical guide to all seven JavaScript regex flags — what each does, when to use it, and common gotchas — with live examples you can run in a browser.
Password vs Passphrase: Entropy, Memorability, and Security in 2026
Why passphrases can be stronger and far easier to remember than complex passwords — explained through entropy, the math behind it, and how to generate both securely.
CSS Clamp for Responsive Typography: No Media Queries Needed
How CSS clamp() replaces brittle media-query font stacks with a single rule that scales smoothly between any two viewport sizes — with a calculator and real-world examples.
CSS Custom Properties: A Practical Guide to Design Tokens
What CSS custom properties (CSS variables) are, how to structure a design token system with them, and how to generate a full color scale — all in your browser.
Regular Expressions Quick Reference: Common Patterns Explained
The most useful regex patterns for developers — email, URL, date, number, word boundaries — explained with examples and a free in-browser tester.
JSON to Go, Rust, TypeScript: Code Generation Tools for Any Language
Stop writing boilerplate struct definitions by hand — paste a JSON sample and generate typed structs for Go, Rust, TypeScript, and PHP instantly in your browser.
What to Put in .gitignore (and Why)
Which files and directories to exclude from version control for Node, Python, Go, Rust, and more — plus the .gitignore pattern syntax every developer should know.
How to Merge, Split, and Rotate PDFs in Your Browser (No Upload Required)
A complete guide to editing PDFs entirely client-side using pdf-lib — merge, split by page range, rotate pages, remove pages, and convert images to PDF without sending files to any server.
Designing for Color Blindness: What Every Developer Should Know
Understand the four main types of color vision deficiency, how they affect your UI, and actionable steps to make your web apps accessible — with tools to simulate and test.
Generating Fake Test Data for Development and QA
Strategies for creating realistic fake names, emails, addresses, and IDs for unit tests, database seeding, UI demos, and privacy-safe data sharing — all without external APIs.
Generating JSON Schema from Example Data: A Practical Guide
Learn how JSON Schema works, how to auto-generate one from an existing JSON document, and how to use it for API validation, TypeScript generation, and documentation.
Why Client-Side Tools Are Safer: Free, Private, No Upload
Most online dev tools upload your data to a server. Client-side tools run entirely in your browser, so your JSON, tokens, and secrets never leave your device — here's why that matters and how to tell the difference.
Pure CSS UI: Buttons, Loaders, and Animations Without JavaScript
Build buttons, loading spinners, and keyframe animations with CSS alone — no JavaScript, no images — for lighter pages and fewer dependencies, with free generators for each.
BMR, TDEE, and Body Fat: The Numbers Behind Your Calorie Goals
How BMR, TDEE, and body-fat percentage relate — what each number means, the formulas behind them, and how to use them to plan a cut or a bulk. All computed in your browser.
How Mortgage Payments Work: PITI, Interest, and PMI Explained
What makes up a monthly mortgage payment — principal, interest, taxes, insurance, and PMI — plus the amortization formula and how to estimate yours in your browser.
URL Encoding and Decoding, Explained
What percent-encoding is, which characters need escaping, encodeURI vs encodeURIComponent, and how to encode or decode URLs safely in your browser.
MD5 vs SHA-256: Which Hash Should You Use?
MD5, SHA-1 and SHA-256 compared — what hashing is, why MD5 and SHA-1 are broken for security, when each is still fine, and how HMAC differs. With free in-browser hash tools.
UUID vs ULID vs Nano ID: Choosing an ID Format
How UUID, ULID and Nano ID differ — randomness, sortability, length, and URL-friendliness — and which to pick for database keys, public IDs, and short links.
How to Format and Validate JSON Online
Format, validate, minify, and convert JSON entirely in your browser — plus the privacy reason you shouldn't upload sensitive payloads to a server.
How to Decode a JWT Safely in Your Browser
What's inside a JWT, the difference between decoding and verifying, and how to read a token's claims without sending a live credential to someone else's server.
Base64 Encoding and Decoding, Explained
What Base64 actually is, when to use it, why it is NOT encryption, the 33% size overhead, and Base64 vs Base64URL — with a free in-browser encoder/decoder.