Every calculator on the Hub is just a formula wrapped in a UI. Here's the core math, then the UI. Paste either into an HTML file and open in a browser.

Step 1 — The formula

Compound interest: FV = P × (1 + r/n)^(n×t)

Where P = principal, r = annual rate as decimal, n = compounds per year, t = years.

Step 2 — The function

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

// Try it:
console.log(compound(10000, 7, 30));
// { futureValue: 81164.97, totalGain: 71164.97, gainPct: 711.65 }

Step 3 — Minimal UI

<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>
<script>
const calc = () => {
  const p = +document.getElementById('p').value;
  const r = +document.getElementById('r').value;
  const t = +document.getElementById('t').value;
  const fv = p * Math.pow(1 + r/100/12, 12*t);
  document.getElementById('out').textContent = 
    '$' + fv.toFixed(2);
};
document.querySelectorAll('input').forEach(el => 
  el.addEventListener('input', calc));
calc();
</script>

Why this matters: The entire logic fits in one function. Everything else — styling, charts, exports — is lipstick. Start with math, add UI last.

DIY/02 Generate an API documentation page from a cURL command ~6 min +

cURL is the universal API lingua franca. If you can describe a request as cURL, you can document it. Here's the transform.

Input

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"}'

Parser

function parseCurl(curl) {
  const result = { method: 'GET', url: '', headers: {}, body: null };
  
  const urlMatch = curl.match(/curl\s+(?:-X\s+\w+\s+)?['"]?([^'"\s]+)/);
  if (urlMatch) result.url = urlMatch[1];
  
  const methodMatch = curl.match(/-X\s+(\w+)/);
  if (methodMatch) result.method = methodMatch[1];
  
  const headerRegex = /-H\s+['"]([^:]+):\s*([^'"]+)['"]/g;
  let m;
  while ((m = headerRegex.exec(curl)) !== null) {
    result.headers[m[1].trim()] = m[2].trim();
  }
  
  const bodyMatch = curl.match(/-d\s+['"]([^'"]+)['"]/);
  if (bodyMatch) {
    try { result.body = JSON.parse(bodyMatch[1]); }
    catch { result.body = bodyMatch[1]; }
  }
  
  return result;
}

Output as Markdown

function toMarkdown(parsed) {
  return `## ${parsed.method} ${parsed.url}

### Headers
${Object.entries(parsed.headers)
  .map(([k, v]) => `- \`${k}\`: ${v}`).join('\n')}

### Body
\`\`\`json
${JSON.stringify(parsed.body, null, 2)}
\`\`\`
`;
}

Production note: Regex parsing works for 90% of cURL commands. For the edge cases (multiline, escaped quotes, binary data), use the yargs-parser package instead. The Hub's production converter does exactly this.

DIY/03 Visualize a PostgreSQL schema as an ERD with zero dependencies ~12 min +

Entity-relationship diagrams look intimidating. They're not. Given the information_schema, you can build one with SVG in a few hundred lines.

Step 1 — Pull the schema

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

-- Get 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 — Layout algorithm (force-directed)

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

  // Run 300 iterations of spring physics
  for (let iter = 0; iter < 300; iter++) {
    // Repulsion between all tables
    for (let i = 0; i < tables.length; i++) {
      for (let j = i + 1; j < tables.length; j++) {
        const a = tables[i], b = tables[j];
        const dx = b.x - a.x, 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 keys
    fks.forEach(fk => {
      const a = tables.find(t => t.name === fk.from);
      const b = tables.find(t => t.name === fk.to);
      if (!a || !b) return;
      const dx = b.x - a.x, 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(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 a rectangle with its columns, draw lines between related tables for FKs. Full implementation in the PostgreSQL ERD tool.

Why force-directed: It produces readable layouts without manual positioning. The repulsion pushes unrelated tables apart; FK attraction pulls related ones together. Result: a layout that looks hand-designed.

DIY/04 Score password strength with entropy (not rules) ~5 min +

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

function entropyBits(password) {
  // Character set size the password draws from
  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;
  
  // Shannon entropy: log2(poolSize) per character
  return password.length * Math.log2(poolSize);
}

function crackTime(bits, guessesPerSec = 1e10) {
  // Offline attack on fast GPU ~ 10 billion guesses/sec
  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`;
}

// Examples
console.log(entropyBits('password123'));
// → 57 bits (crackable in minutes)
console.log(entropyBits('correct horse battery staple'));
// → 178 bits (crackable in ~10^43 years)

Caveat: Entropy assumes random selection from the pool. Real passwords aren't random — "password123" has dictionary exposure that raw entropy misses. Production tools (including ours) layer dictionary matching on top.

DIY/05 Calculate TDEE and macros without a coach ~7 min +

Coaches charge $200 for a spreadsheet. Here's the same spreadsheet.

BMR (Mifflin-St Jeor, the accurate one)

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

TDEE with activity multiplier

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

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

Macro split for a cut / recomp / bulk

function macros(tdeeVal, goal, weightKg) {
  const deficit = { cut: -500, recomp: 0, bulk: 300 }[goal];
  const calories = tdeeVal + deficit;
  
  // Protein: 1.8g/kg (optimal for most)
  const proteinG = weightKg * 1.8;
  // Fat: 25% of calories
  const fatG = (calories * 0.25) / 9;
  // Carbs: remainder
  const carbsG = (calories - proteinG*4 - fatG*9) / 4;
  
  return { calories, proteinG, fatG, carbsG };
}

n=1 disclaimer: These are population averages. Your actual TDEE varies ±15% based on NEAT, thyroid, microbiome, sleep. Track for 2 weeks, adjust based on scale + photos, not single formulas.

DIY/06 Analyze an SSL certificate from the command line ~4 min +

Before you trust a site, check its cert. Three commands.

Get the cert

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

Check expiry

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

Check cipher suites

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

You want TLS 1.2 minimum, TLS 1.3 preferred. Any cipher with RC4, DES, or MD5 is a red flag.

05 /

Try commands. Live.

An interactive terminal. Type help to see available commands.

legitlads@hub ~ %

legitlads@hub:~$ welcome

Welcome to the LegitLads Hub shell. v2026.04 5000+ tools available. Type help for commands.

legitlads@hub:~$ █

06 /

How we compare.

Not all tool directories are the same. Here's the honest breakdown.

Feature	LegitLads Hub	Typical SaaS Tool	Ad-Farm Sites
Price	Free, forever	$9–$99 / month	"Free" + 47 ads
Signup required	Never	Always	For "premium" features
Client-side calc	✓ No data leaves browser	Server-side (tracked)	Server-side (resold)
Tool count	5000+	1–3	Varies
Open methodology	✓ Documented	Sometimes	Rarely
Shareable results	✓ Permalinks	PDF export (paid)	Screenshots only
API access	Coming Q3	Enterprise tier	None
Ads	None	None	Everywhere

07 /

Questions we actually get asked.

Q/01 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 and the newsletter. You're not the product — the blog is. Use the tools, ignore the blog. We're fine either way.

Q/02 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 and note the change in the tool's changelog.

Q/03 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 don't have a database of "who calculated what." The only telemetry is anonymous page views (which tool was opened, not what you typed).

Q/04 Can I embed a Hub tool on my site? +

Embed support is rolling out Q2 2026. Each tool will have an <iframe> snippet and an attribution-required license. Until then, link to the tool directly — backlinks from your content help us help you.

Q/05 I found a bug / I want a tool that doesn't exist. +

Request queue: hub@legitlads.com. Bug reports: the "Report" button on any tool page. Feature requests get shipped roughly in order of how many people ask. If you want to jump the line, write the tool yourself and submit a PR — contributor docs at /hub/contribute.

Q/06 Why the "Tech-Noir" aesthetic? +

Because most utility sites look like they were designed in 2012. The Hub is for practitioners — engineers, operators, analysts. The aesthetic signals that this is a tool for people who care about precision. Black-and-signal-red was chosen specifically because it photographs poorly on LinkedIn carousels, which filters out the audience we don't want.

Professional-grade tools. All free. Forever.

Six categories. One mission.

Trending this cycle.

The workflow. End to end.

Search or browse

Input your values

Get the answer

Share or iterate

DIY guides. No gatekeeping.

Support