Free guides on AI tools, investing, and productivity — updated daily. Join Free

Legit LadsSmart Insights for Ambitious Professionals

Support

The LegitLads Hub — Complete Knowledge Base

5000+ professional tools. All free. Forever. A long-form guide to the Hub, its philosophy, how to use it, and how to build your own tools.

What This Document Is

This is the full user-facing knowledge base for the LegitLads Hub. If you're a new visitor, start at the top and scroll. If you're a builder, jump to the DIY section. If you're a skeptic, jump to the FAQ.

Everything here is plain text. Paste it into any WordPress post, Google Doc, Notion page, or print it out and tape it to your wall. It renders cleanly anywhere.

Table of Contents

  1. What the Hub Is
  2. The Six Categories
  3. Platform Statistics
  4. How the Hub Works (End-to-End)
  5. Featured Tools & What They Do
  6. Six DIY Guides (Build Your Own)
  7. How We Compare to Other Tool Sites
  8. Frequently Asked Questions
  9. Platform Philosophy
  10. Get Involved

1. What the Hub Is

The LegitLads Hub is a collection of 5000+ professional-grade tools — calculators, developer utilities, converters, and analyzers — built for engineers, operators, analysts, and serious builders.

What makes it different:

  • 100% free, no subscriptions, no tiers
  • Zero signup required to use any tool
  • Calculations run entirely in your browser — no data leaves your device
  • No ads, no pop-ups, no email gates
  • Every methodology is documented and auditable
  • Shareable result permalinks for every output

The Hub sits at legitlads.com/hub and is a companion to the main blog at legitlads.com. Blog readers discover tools; tool users discover the blog. It's one ecosystem with two entry points.

2. The Six Categories

Every tool in the Hub lives in one of six disciplines. Here's what's in each.

T-01 — Technical Services (59 tools)

For developers, DevOps engineers, and security practitioners.

  • API Documentation Generators (13 tools) — OpenAPI, Postman, cURL, GraphQL
  • Database Schema Visualization (11 tools) — MySQL, PostgreSQL, MongoDB, Oracle
  • Code Dependency Analyzers (12 tools)
  • Automated Accessibility Auditing (10 tools)
  • Security Analysis (8 tools) — SSL/TLS, password strength, prompt cost estimation
  • Performance Monitoring (5 tools)

T-02 — Data & Analytics (48 tools)

For data engineers, analysts, and ML practitioners.

  • Visualization generators
  • ETL helpers
  • Statistical calculators
  • ML model cost estimators

T-03 — Productivity & Automation (42 tools)

For anyone who wants to get more done without buying another SaaS subscription.

  • Meeting cost calculators
  • Password tools
  • Workflow automation templates
  • Focus timers and habit trackers

T-04 — Niche Calculators (37 tools)

The long tail — specialty calculations for edge cases that mainstream tools skip.

  • Industry-specific formulas
  • Regional tax edge cases
  • Unusual unit conversions

T-05 — Content & Media (31 tools)

For writers, creators, and SEO practitioners.

  • Word counters with reading time
  • SEO analyzers
  • Image optimizers
  • Schema markup generators

T-06 — Professional Calculators (84 tools)

The classics, done properly.

  • Financial — compound interest, retirement, WACC, US tax 2026
  • Health & Fitness — BMI, TDEE, BMR, Harris-Benedict
  • Math & Science — perimeter, Pythagorean, rate of change
  • Automotive — EV charging, fuel economy, loan calculators
  • Construction — rafter, roof pitch, concrete footing

3. Platform Statistics

These are the current numbers. They update nightly.

  • Tools online: 5,000+
  • Active monthly users: 50,000+
  • Calculations per day: 10 million+
  • Countries served: 180+
  • Average response time: 12ms
  • Uptime (last 90 days): 99.97%
  • Categories: 6 top-level, 50+ subcategories
  • New tools per week: 15–25

4. How the Hub Works (End to End)

Four steps. No fluff.

Step 1 — Search or Browse

Hit ⌘K (Mac) or Ctrl+K (Windows/Linux) anywhere on the Hub for instant search across all tools. Or drill through the six categories from the main navigation. No signup wall, no paywall, no email capture.

Example search flow:

> tools find "compound interest"
  3 matches · financial · 0.12ms

Step 2 — Input Your Values

Every tool loads above the fold. No 2000-word SEO essay before the calculator. No ad pre-roll. No "sign up to unlock" friction. The interface is the page.

Example input:

principal: $10,000
rate: 7%
years: 30

Step 3 — Get the Answer

Calculations run client-side in your browser via JavaScript. No data is sent to our servers. No logging of inputs. No database of "who calculated what." Results stream as you type.

Example output:

→ future_value: $76,122.55
→ total_gain: +$66,122.55
→ gain_pct: +661%

Step 4 — Share or Iterate

Every output can be permalinked. Copy the URL, share it, cite it in a document. The link encodes the inputs, so anyone who opens it sees the same result you did. You can also export as CSV or chain outputs into the next tool.

Example permalink:

legitlads.com/r/k2f9a1
(shareable · permanent · no tracking)

5. Featured Tools & What They Do

Nine of the most-used tools in the Hub, with honest descriptions.

OpenAPI/Swagger Documentation Generator

Paste an OpenAPI 3.0 spec, get interactive API documentation with a try-it-out playground. Supports YAML and JSON input. Outputs embedded HTML you can host anywhere. Used by: 24,000+ developers this month Category: Technical Services → API Documentation

Postman Collection to Docs Converter

Upload a Postman collection JSON export, get production-ready Markdown or HTML documentation. Preserves environments, variables, and example requests. Used by: 18,000+ this month Category: Technical Services → API Documentation

PostgreSQL ERD Generator

Paste a schema dump or connection string (read-only), get a visual entity-relationship diagram. Force-directed layout, exports as SVG or PNG. Used by: 15,000+ this month Category: Technical Services → Database Visualization

MySQL Schema Diagram Generator

Same as above, MySQL dialect. Handles foreign keys, views, and indexes. Supports MySQL 5.7 through 8.4. Used by: 12,000+ this month Category: Technical Services → Database Visualization

Compound Interest Calculator

Long-term growth modeling with tax-adjusted scenarios, inflation adjustment, and monthly contributions. Charts projected value over time. Used by: 47,000+ this month Category: Professional Calculators → Financial

US Tax Breakdown 2026

Federal income tax + state tax + FICA (Social Security + Medicare) broken down line-by-line. Uses current 2026 brackets, updated when Congress passes changes. Used by: 31,000+ this month Category: Professional Calculators → Financial

TDEE Calculator

Total Daily Energy Expenditure using Mifflin-St Jeor (the accurate BMR formula) multiplied by activity level. Includes macro split recommendations. Used by: 22,000+ this month Category: Professional Calculators → Health & Fitness

Password Strength Tester

Entropy-based scoring with dictionary matching. Estimates offline GPU crack time in realistic terms (hours, years, universe-lifetimes). Does not send your password anywhere. Used by: 19,000+ this month Category: Productivity & Automation → Password Tools

SSL/TLS Analyzer

Tests a domain's certificate validity, cipher suites, protocol versions, and configuration. Qualys-style grading (A+ through F) with specific remediation advice. Used by: 8,000+ this month Category: Technical Services → Security Analysis

6. Six DIY Guides (Build Your Own)

Every tool on the Hub is a formula wrapped in a UI. Here's how to build your own. These are hands-on walkthroughs with working logic.

DIY 01 — Build Your Own Compound Interest Calculator

Difficulty: Beginner Time: 8 minutes Prerequisites: Basic JavaScript, an HTML file, a browser

The formula: Future Value = Principal × (1 + rate/compounds)^(compounds × years)

Where:

  • Principal = starting amount
  • Rate = annual interest rate as a decimal (7% = 0.07)
  • Compounds = how many times per year interest compounds (12 for monthly)
  • Years = how long you're holding

Step 1 — The function

Create a file called compound.html. Inside a script tag, define the function:

function compound(principal, ratePct, years, compoundsPerYear) {
  const r = ratePct / 100;
  const n = compoundsPerYear || 12;
  const fv = principal * Math.pow(1 + r / n, n * years);
  return {
    futureValue: fv,
    totalGain: fv - principal,
    gainPct: ((fv / principal) - 1) * 100
  };
}

Test it in the browser console:

compound(10000, 7, 30);
// { futureValue: 81164.97, totalGain: 71164.97, gainPct: 711.65 }

Step 2 — The UI

Add three inputs and a display div:

<input id="p" type="number" value="10000" />
<input id="r" type="number" value="7" />
<input id="t" type="number" value="30" />
<div id="out"></div>

Step 3 — Wire it up

function calc() {
  const p = Number(document.getElementById('p').value);
  const r = Number(document.getElementById('r').value);
  const t = Number(document.getElementById('t').value);
  const result = compound(p, r, t);
  document.getElementById('out').textContent =
    '$' + result.futureValue.toFixed(2);
}

document.querySelectorAll('input').forEach(function(el) {
  el.addEventListener('input', calc);
});
calc();

Open the file in your browser. You now have a working compound interest calculator.

Why this matters: The entire logic fits in one function. Everything else — styling, charts, exports — is decoration. Start with the math, add UI last. This is how every tool on the Hub was built.

DIY 02 — Generate API Documentation from a cURL Command

Difficulty: Intermediate Time: 6 minutes Prerequisites: JavaScript, regex basics

Every developer knows cURL. If you can describe an API request as cURL, you can document it. Here's the transform.

Input (what you have):

curl -X POST https://api.example.com/v1/users \
  -H "Authorization: Bearer sk_live_abc123" \
  -H "Content-Type: application/json" \
  -d '{"name": "Alice", "email": "alice@example.com"}'

Output (what you want): A clean Markdown doc with endpoint, method, headers, and body.

The parser:

function parseCurl(curl) {
  const result = {
    method: 'GET',
    url: '',
    headers: {},
    body: null
  };

  // Find URL (first http/https)
  const urlMatch = curl.match(/https?:\/\/[^\s'"]+/);
  if (urlMatch) result.url = urlMatch[0];

  // Find method
  const methodMatch = curl.match(/-X\s+(\w+)/);
  if (methodMatch) result.method = methodMatch[1];

  // Find headers
  const headerRegex = /-H\s+['"]([^:]+):\s*([^'"]+)['"]/g;
  let m;
  while ((m = headerRegex.exec(curl)) !== null) {
    result.headers[m[1].trim()] = m[2].trim();
  }

  // Find body
  const bodyMatch = curl.match(/-d\s+['"]([^'"]+)['"]/);
  if (bodyMatch) {
    try {
      result.body = JSON.parse(bodyMatch[1]);
    } catch (e) {
      result.body = bodyMatch[1];
    }
  }

  return result;
}

The Markdown renderer:

function toMarkdown(parsed) {
  let md = '## ' + parsed.method + ' ' + parsed.url + '\n\n';
  md += '### Headers\n';
  for (const key in parsed.headers) {
    md += '- `' + key + '`: ' + parsed.headers[key] + '\n';
  }
  if (parsed.body) {
    md += '\n### Body\n```json\n';
    md += JSON.stringify(parsed.body, null, 2);
    md += '\n```\n';
  }
  return md;
}

Production note: Regex parsing works for 90% of cURL commands. For the edge cases (multiline arguments, escaped quotes, binary data uploads), use the yargs-parser package instead of rolling your own. The Hub's production converter handles these cases but for your own scripts, the regex version is fine.

DIY 03 — Visualize a PostgreSQL Schema as an ERD

Difficulty: Advanced Time: 12 minutes Prerequisites: SQL, JavaScript, basic physics intuition

Entity-relationship diagrams look intimidating. They're not. Given access to information_schema, you can build one with a force-directed layout in a few hundred lines.

Step 1 — Pull the schema

Run this query against your Postgres database:

SELECT table_name, column_name, data_type
FROM information_schema.columns
WHERE table_schema = 'public'
ORDER BY table_name, ordinal_position;

Then pull foreign keys:

SELECT
  tc.table_name,
  kcu.column_name,
  ccu.table_name AS foreign_table,
  ccu.column_name AS foreign_column
FROM information_schema.table_constraints tc
JOIN information_schema.key_column_usage kcu
  ON tc.constraint_name = kcu.constraint_name
JOIN information_schema.constraint_column_usage ccu
  ON ccu.constraint_name = tc.constraint_name
WHERE tc.constraint_type = 'FOREIGN KEY';

Step 2 — The force-directed layout

The idea: treat each table as a charged particle. Tables repel each other (so they don't overlap). Foreign keys act as springs pulling related tables together. Run the simulation for 300 iterations and you get a layout that looks hand-designed.

function layoutTables(tables, fks, width, height) {
  // Random initial positions
  tables.forEach(function(t) {
    t.x = Math.random() * width;
    t.y = Math.random() * height;
    t.vx = 0;
    t.vy = 0;
  });

  // 300 iterations of physics
  for (let iter = 0; iter < 300; iter++) {
    // Repulsion between every pair of tables
    for (let i = 0; i < tables.length; i++) {
      for (let j = i + 1; j < tables.length; j++) {
        const a = tables[i];
        const b = tables[j];
        const dx = b.x - a.x;
        const dy = b.y - a.y;
        const d = Math.sqrt(dx * dx + dy * dy) || 1;
        const force = 5000 / (d * d);
        a.vx -= (dx / d) * force;
        a.vy -= (dy / d) * force;
        b.vx += (dx / d) * force;
        b.vy += (dy / d) * force;
      }
    }

    // Attraction along foreign key edges
    fks.forEach(function(fk) {
      const a = tables.find(function(t) { return t.name === fk.from; });
      const b = tables.find(function(t) { return t.name === fk.to; });
      if (!a || !b) return;
      const dx = b.x - a.x;
      const dy = b.y - a.y;
      a.vx += dx * 0.01;
      a.vy += dy * 0.01;
      b.vx -= dx * 0.01;
      b.vy -= dy * 0.01;
    });

    // Apply velocity with damping
    tables.forEach(function(t) {
      t.x += t.vx * 0.5;
      t.y += t.vy * 0.5;
      t.vx *= 0.85;
      t.vy *= 0.85;
    });
  }

  return tables;
}

Step 3 — Render as SVG

Render each table as an SVG rectangle with its column list inside. Draw SVG lines between related tables for the foreign keys. The full implementation is on the Hub — this is the algorithm at its core.

Why force-directed beats grid layouts: Grid layouts are readable for 5 tables. They're unreadable for 50. Force-directed scales naturally because it's solving the constraint you actually care about: minimize edge crossings, keep related things close, keep unrelated things apart.

DIY 04 — Score Password Strength With Entropy

Difficulty: Beginner Time: 5 minutes Prerequisites: JavaScript, log base 2

The "must contain uppercase, number, symbol" rule is security theatre. Entropy is the real measure. Here's how to compute it.

The concept: Every character in a password is drawn from some pool. The pool size determines how much information each character carries. Shannon entropy per character = log2(pool size). Total entropy = entropy per character × length.

The function:

function entropyBits(password) {
  let poolSize = 0;
  if (/[a-z]/.test(password)) poolSize += 26;
  if (/[A-Z]/.test(password)) poolSize += 26;
  if (/[0-9]/.test(password)) poolSize += 10;
  if (/[^a-zA-Z0-9]/.test(password)) poolSize += 32;
  return password.length * Math.log2(poolSize);
}

Translate entropy to crack time:

Assume an offline attack on a fast GPU cluster — roughly 10 billion guesses per second is realistic in 2026.

function crackTime(bits) {
  const guessesPerSec = 1e10;
  const seconds = Math.pow(2, bits - 1) / guessesPerSec;

  if (seconds < 60) return seconds.toFixed(1) + ' seconds';
  if (seconds < 3600) return (seconds / 60).toFixed(1) + ' minutes';
  if (seconds < 86400) return (seconds / 3600).toFixed(1) + ' hours';
  if (seconds < 31536000) return (seconds / 86400).toFixed(1) + ' days';
  return (seconds / 31536000).toExponential(2) + ' years';
}

Real-world examples:

  • password123 — 57 bits — crackable in minutes
  • Tr0ub4dor&3 — 60 bits — crackable in hours (the famous XKCD example)
  • correct horse battery staple — 178 bits — crackable in 10^43 years

Important caveat: Entropy assumes truly random selection. Real passwords aren't random. "password123" has dictionary exposure that raw entropy calculation misses. Production strength testers (including the one on the Hub) layer a dictionary match on top of entropy scoring, plus checks against breached-password databases like Have I Been Pwned.

DIY 05 — Calculate TDEE and Macros Without a Coach

Difficulty: Beginner Time: 7 minutes Prerequisites: None

Coaches charge $200 for a spreadsheet that does exactly this. Here's the spreadsheet.

Step 1 — BMR (Basal Metabolic Rate)

Use Mifflin-St Jeor. It's the most accurate for the general population (the Harris-Benedict equation is older and overestimates by about 5%).

function bmr(sex, weightKg, heightCm, ageYears) {
  const base = 10 * weightKg + 6.25 * heightCm - 5 * ageYears;
  return sex === 'male' ? base + 5 : base - 161;
}

Step 2 — TDEE (Total Daily Energy Expenditure)

Multiply BMR by an activity factor.

const ACTIVITY = {
  sedentary: 1.2,    // desk job, no exercise
  light: 1.375,      // light exercise 1-3 days/week
  moderate: 1.55,    // moderate exercise 3-5 days/week
  active: 1.725,     // heavy exercise 6-7 days/week
  extreme: 1.9       // 2x daily training, physical job
};

function tdee(bmrVal, activityLevel) {
  return bmrVal * ACTIVITY[activityLevel];
}

Step 3 — Macros for a cut, recomp, or bulk

function macros(tdeeVal, goal, weightKg) {
  const deficit = { cut: -500, recomp: 0, bulk: 300 }[goal];
  const calories = tdeeVal + deficit;

  // Protein: 1.8g per kg bodyweight (optimal for most)
  const proteinG = weightKg * 1.8;

  // Fat: 25% of total calories (9 cal per gram)
  const fatG = (calories * 0.25) / 9;

  // Carbs: whatever's left (4 cal per gram)
  const carbsG = (calories - proteinG * 4 - fatG * 9) / 4;

  return {
    calories: calories,
    proteinG: proteinG,
    fatG: fatG,
    carbsG: carbsG
  };
}

Example: A 30-year-old male, 80kg, 180cm, moderately active, wants to cut:

  • BMR: 1755 cal/day
  • TDEE: 2720 cal/day
  • Cut target: 2220 cal/day
  • Protein: 144g, Fat: 62g, Carbs: 218g

n=1 disclaimer: These formulas are population averages. Your actual maintenance varies ±15% based on non-exercise activity (NEAT), thyroid function, gut microbiome, sleep quality, and genetics. Track for two weeks, adjust based on scale + photos, not single-day formulas. The math is a starting point, not a prescription.

DIY 06 — Analyze an SSL Certificate From the Command Line

Difficulty: Intermediate Time: 4 minutes Prerequisites: Terminal, OpenSSL (pre-installed on Mac/Linux)

Before you trust a site — especially one handling payments, logins, or personal data — check its certificate. Three commands.

Command 1 — Get the full cert details:

echo | openssl s_client -servername legitlads.com \
  -connect legitlads.com:443 2>/dev/null \
  | openssl x509 -noout -text

This dumps the entire certificate: issuer, subject, public key, signature algorithm, extensions, SAN list.

Command 2 — Check expiry:

echo | openssl s_client -servername legitlads.com \
  -connect legitlads.com:443 2>/dev/null \
  | openssl x509 -noout -dates

Returns notBefore and notAfter dates. If notAfter is within 30 days, the site owner is about to have a bad day.

Command 3 — Check cipher suites:

nmap --script ssl-enum-ciphers -p 443 legitlads.com

This tests which TLS versions and cipher suites the server supports. What you want:

  • TLS 1.3 supported (ideal)
  • TLS 1.2 as minimum fallback
  • No SSL 3.0, TLS 1.0, or TLS 1.1 (all deprecated)
  • No ciphers containing RC4, DES, 3DES, or MD5 (all broken)

Red flags to watch for:

  • Self-signed certs on production sites (legitimate for internal services, never for public)
  • Wildcard certs on sensitive domains (acceptable but wider attack surface)
  • Certs issued by CAs you've never heard of
  • Cipher negotiation that still allows TLS 1.0

If you want this as a point-and-click interface, the Hub's SSL/TLS Analyzer does all three checks plus Qualys-style grading.

7. How We Compare to Other Tool Sites

An honest breakdown. No marketing puffery.

LegitLads Hub vs Typical SaaS Tool

  • Price: Free forever vs $9-99/month
  • Signup: Never vs always required
  • Calculation location: Your browser vs their servers (they log everything)
  • Tool count: 5000+ vs 1-3 per product
  • Open methodology: Yes, documented vs usually proprietary
  • Shareable results: Permalinks vs PDF export on paid tier
  • API access: Coming Q3 2026 vs enterprise tier only
  • Ads: None vs none

LegitLads Hub vs Ad-Farm Calculator Sites

  • Price: Free vs "free" + 47 ads per page
  • Signup: Never vs for "premium" features you don't need
  • Calculation location: Your browser vs their servers (data often resold)
  • Tool count: 5000+ vs varies, often just SEO bait
  • Open methodology: Yes vs rarely documented
  • Shareable results: Yes vs screenshots only
  • API access: Coming vs none
  • Ads: None vs everywhere, autoplaying video, popups

The honest tradeoff: Paid SaaS tools have deeper integrations (your data syncs with your other apps). Ad-farm sites rank well on Google for long-tail calculator queries. The Hub trades integration depth for breadth and privacy. Pick the tool that fits your use case.

8. Frequently Asked Questions

Q1: How is this free? What's the catch?

No catch. The Hub is a loss-leader for the blog. Tools bring traffic, traffic reads the blog, the blog monetizes through affiliate partnerships (clearly disclosed) and the newsletter. You're not the product — the blog is. Use the tools, ignore the blog. We're fine either way.

Q2: Why should I trust the calculations?

Every tool's methodology is documented on its page — formulas, assumptions, edge cases, known limitations. If you find a bug, the "Report issue" link on each tool goes straight to the engineering queue. We patch within 48 hours for critical bugs, within a week for minor ones, and note every change in the tool's changelog. Where applicable, we cite the academic sources for formulas (Mifflin-St Jeor for BMR, Shannon for entropy, Modigliani-Miller for WACC, etc.).

Q3: Does my data get sent anywhere?

No. Calculations run in your browser via JavaScript. We don't log inputs. We don't store results. We have no database of "who calculated what." The only telemetry is anonymous page views — we know the /compound-interest/ page was loaded 47,000 times this month, but not what anyone typed into it. You can verify this by opening your browser's Network tab while using any tool. No outbound requests fire when you hit "calculate."

Q4: Can I embed a Hub tool on my own site?

Embed support rolls out Q2 2026. Each tool will have an iframe snippet and a simple attribution-required license (link back to the tool's page). Until then, link to the tool directly from your content — backlinks help us invest in more tools, and the referral traffic helps you become a resource your audience trusts.

Q5: I found a bug / I want a tool that doesn't exist.

Bug reports: the "Report" button on any tool page goes directly to engineering. Feature requests: email hub@legitlads.com with the tool idea and a specific use case. We ship roughly in order of request frequency — if five people ask for the same tool within a month, it gets prioritized. If you want to skip the queue entirely, contributor docs are at /hub/contribute and we accept PRs.

Q6: Why the dark, technical aesthetic?

Most utility websites look like they were designed in 2012. The Hub is built for practitioners — engineers, operators, analysts, quants. The visual language signals that this is a tool for people who care about precision, not decoration. Black and red was chosen specifically because it photographs poorly on LinkedIn carousels, which filters out the audience we're not building for.

Q7: Do the tools work offline?

Most do. Once a tool's page has loaded, calculations run client-side and work without an internet connection. PWA (Progressive Web App) support is on the roadmap for Q4 2026, which will let you install the Hub as an app on mobile and use tools fully offline.

Q8: Why the "5000+ tools" claim when I can only find hundreds?

Fair question. The 5000+ figure includes tools in active development and tools that exist as utility scripts without a full UI wrapper. Publicly accessible polished tools number around 300. We're working through the backlog of wrapping the rest. If you want to help prioritize which tools ship next, the monthly poll is in the newsletter.

Q9: What's the difference between the Hub and legitlads.com?

legitlads.com is the editorial blog — long-form guides, analysis, field notes. legitlads.com/hub is the tool directory. They share a brand and are cross-linked, but you can use either without ever touching the other. Blog readers tend to land on the Hub for specific calculators mentioned in articles. Hub users sometimes discover the blog through the footer. One ecosystem, two doors.

Q10: Who's behind this?

LegitLads is an editorial and engineering team based across three continents. The blog is run by the editorial team; the Hub is maintained by a small platform engineering group. We don't emphasize individual bylines because the Hub is the product — no single person is the face of it. The editorial blog has named contributors when relevant.

9. Platform Philosophy

A few principles that guide what gets built and what doesn't.

Signal, not noise

Every tool earns its slot by doing one thing well. We don't ship tools that duplicate existing ones unless the new one is measurably better. "Yet another BMI calculator" doesn't make it past review; "BMI calculator with body fat percentage, using the four-site skinfold method" does.

Privacy as a default, not a feature

Client-side calculation isn't marketing — it's the only way to build utility tools ethically. The moment we log inputs, we become a different kind of product. We're not interested in being that product.

Open methodology

If we can't show the formula, we don't ship the tool. This rules out "proprietary algorithms" entirely. Every calculation you run on the Hub is reproducible on paper, in Excel, or in any scripting language. The tool is a convenience, not a black box.

Honest limitations

Every tool notes what it doesn't do. The BMI calculator mentions that BMI is a population-level metric and misleading for athletes. The compound interest calculator notes that 7% average returns assume equity exposure over long timeframes. The password tester clarifies that entropy is a lower bound, not a ceiling. Hiding limitations is how users make bad decisions.

Fast, or nothing

Every tool page has a performance budget — Largest Contentful Paint under 1.5 seconds, Total Blocking Time under 200ms. Tools that can't meet the budget don't ship. This rules out bloated frameworks, heavy ads, and fancy animations on utility surfaces.

No dark patterns

No fake urgency ("3 spots left!"), no manipulative countdown timers, no opt-out-buried newsletter signups, no "are you sure you want to leave?" modals. If users want to leave, they leave. If they want to come back, they come back on their own.

10. Get Involved

Subscribe to the newsletter

One email a week. New tools, DIY walkthroughs, field notes. No listicles, no affiliate spam, no "5 productivity hacks." Unsubscribe in one click. Signup: legitlads.com/subscribe

Report a bug

Click "Report issue" on any tool page. Describe what you expected vs what happened. Include browser, OS, and reproduction steps. We patch fast.

Request a tool

Email hub@legitlads.com. Subject line: the tool name. Body: the use case and what you're currently using instead. We prioritize by request frequency.

Contribute code

Contributor documentation: legitlads.com/hub/contribute. We accept PRs for new tools, bug fixes, and performance improvements. All contributions are reviewed within a week.

Follow the build

  • Twitter: @legitlads
  • YouTube: youtube.com/legitlads
  • Facebook: facebook.com/legitlads
  • Instagram: @dustinthewind_legitlads

Contact

  • Hub questions: hub@legitlads.com
  • Editorial: editorial@legitlads.com
  • Security disclosures: security@legitlads.com
  • Press: hello@legitlads.com

Closing

The Hub exists because the internet used to be full of free, useful utility sites built by people who cared about the craft. Somewhere around 2015, that ecosystem started collapsing under ads, paywalls, and SaaS bundling. The Hub is an attempt to rebuild a piece of it.

Every tool is free. Every methodology is documented. Your data stays on your device. If a tool saves you five minutes, we've done our job. If it saves you from paying for another SaaS subscription, even better.

Level up. Live legit.

© 2026 LegitLads. All rights reserved. Built for builders. GDPR compliant. No trackers. No nonsense.