DEV Community: Leo Chang

How I Built a Self-Employment Tax Calculator with Zero Dependencies

Leo Chang — Tue, 04 Aug 2026 16:42:52 +0000

When you get a W-2, the government takes its cut before you ever see the money. Social Security, Medicare, all of it, handled by payroll software. When you're self-employed, you get to do that math yourself, and the "15.3% self-employment tax" everyone quotes is quietly wrong in three ways. It's 15.3% of 92.35% of your income, the Social Security half stops at a wage cap, and if you earn enough, a 0.9% surtax kicks in on top.

I built a calculator that gets all three right in a single HTML file. No frameworks, no build step, no CDN, no backend. Here's how the math works and the code behind it.

The tax formula challenge

Self-employment tax is the self-employed version of FICA: 12.4% for Social Security plus 2.9% for Medicare. Three details turn "multiply by 15.3%" into actual logic:

The 92.35% adjustment. Because the employer half of the tax is deductible, you only pay SE tax on 92.35% of your net income (IRC §1402(a)(12)).
The Social Security wage base. The 12.4% portion only applies up to a cap: $184,500 for 2026, $176,100 for 2025. And here's the part most calculators miss: W-2 wages count against that cap too.
The Additional Medicare surtax. Above $200,000 (single filers), an extra 0.9% applies. The threshold isn't indexed, so it catches more people every year.

Get any of these wrong and you're off by real money. Most free calculators I tried do "income × 15.3%" and stop. This is the SE tax layer only. Income tax, state tax, and the qualified business income deduction are separate problems, and deliberately out of scope.

Rates as data, not magic numbers

The first decision was to stop hardcoding numbers inside the logic. Tax rates change every year, so they live in one object, one entry per year:

// 2026 rates (source: tax-formula-reference.md)
const RATES = {
  '2026': { ssBase: 184500, ssRate: 0.124, medRate: 0.029, extraRate: 0.009, extraThreshold: 200000 },
  '2025': { ssBase: 176100, ssRate: 0.124, medRate: 0.029, extraRate: 0.009, extraThreshold: 200000 },
  '2024': { ssBase: 168600, ssRate: 0.124, medRate: 0.029, extraRate: 0.009, extraThreshold: 200000 }
};
const ADJUSTMENT = 0.9235; // IRC §1402(a)(12)
const DEDUCTION_RATE = 0.5;  // IRC §164(f)

Updating the tool next year means editing one object, not hunting through functions.

The core calculate() function

The whole product hinges on this function. Everything around it is a form, a results table, and some CSS.

function calculate() {
  const netIncome = parseFloat(document.getElementById('netIncome').value) || 0;
  const w2Wages = parseFloat(document.getElementById('w2Wages').value) || 0;
  const rates = RATES[document.getElementById('taxYear').value];

  // Step 1: the 92.35% adjustment
  const adjusted = netIncome * ADJUSTMENT;

  // Step 2: Social Security, 12.4% up to the wage base.
  // W-2 wages count against the base, so subtract them first.
  const ssRemainingBase = Math.max(0, rates.ssBase - w2Wages);
  const ssTaxable = Math.min(adjusted, ssRemainingBase);
  const ssTax = ssTaxable * rates.ssRate;

  // Step 3: Medicare, 2.9% on all adjusted income (no cap)
  const medTax = adjusted * rates.medRate;

  // Step 4: Additional Medicare, 0.9% above the $200K threshold
  const extraTaxable = Math.max(0, netIncome - rates.extraThreshold);
  const extraTax = extraTaxable * rates.extraRate;

  const totalTax = ssTax + medTax + extraTax;
  const deduction = totalTax * DEDUCTION_RATE; // 50% is deductible (IRC §164(f))
  const effectiveRate = (totalTax / netIncome) * 100;
  // ...then write everything to the DOM
}

The real function ends with the DOM updates and a quarterly-payment estimate. I trimmed those here to focus on the math. Four steps, four lines of arithmetic, two edge-case guards.

For $85,000 of net income in 2026: adjusted income is $78,497, Social Security tax is $9,733, Medicare is $2,276, total is $12,010, and the deductible half is $6,005. Effective rate: 14.13%, not the 15.3% you'll see quoted everywhere.

The edge case most calculators get wrong: W-2 wages

The pair of lines I'm most happy with:

const ssRemainingBase = Math.max(0, rates.ssBase - w2Wages);
const ssTaxable = Math.min(adjusted, ssRemainingBase);

If you're a freelancer with a day job, your W-2 Social Security tax doesn't reset just because you also have 1099 income. The $184,500 cap is shared between both. With 2026 numbers:

Scenario	SS-taxable SE income
$85K SE income, no W-2	$78,497 (the full 92.35% adjusted amount)
$50K SE income + $160K W-2	$24,500 (only the room left under the cap)
$30K SE income + $200K W-2	$0 (the cap is already used up)

Without the Math.max(0, ...) guard, the second scenario would produce a negative base and a negative tax. Clamping to zero is what makes the third scenario correct: once your W-2 wages exceed the base, your self-employment Social Security tax is exactly $0. You still pay 2.9% Medicare on every dollar, because Medicare has no cap.

The same Math.max(0, ...) pattern handles the surtax: Math.max(0, netIncome - rates.extraThreshold) stays at zero until income crosses $200K, so the surtax row in the breakdown stays at $0 until it matters.

Lessons learned

A calculator is only as good as the tax rules it encodes. The "15.3%" shortcut is wrong at every income level, just less wrong below the wage base. Read the IRS publication, then encode each adjustment separately.
Edge cases are where the value is. The W-2 plus 1099 combination is extremely common, and it's the one thing every other free calculator I tried ignored.
Zero dependencies is a feature. The page loads instantly, works offline, and "view source" doubles as your documentation. There is no bundle to debug, no dependency to audit.
Guard your divisions. If someone clears the income field, totalTax / netIncome is 0 / 0, which renders as NaN% in the effective-rate card. In hindsight I'd clamp net income before computing the rate.
Keep rates as data. The moment you hardcode 184500 inside a function, someone will copy it into the wrong tax year.

The whole thing, from first draft to deployed page, took a few hours. Cost: $0.

Try it

The live tool is here: Self-Employment Tax Calculator

It's a single HTML file. Open the page, view source, and the entire implementation is right there, commented and readable. If you want the background on how SE tax actually works, there's a companion guide on the Inisyght blog.

I Built a Free Debt Calculator with Pure HTML/CSS/JS

Leo Chang — Mon, 20 Jul 2026 12:15:10 +0000

I Built a Free Debt Calculator with Pure HTML/CSS/JS

A few weeks ago I realized something: every debt payoff calculator I found online either required sign-up, looked like it was designed in 2005, or only showed you one strategy at a time.

So I built my own. Zero dependencies. Zero frameworks. Zero backend.

Here's the full walkthrough of how it works under the hood.

The MVP Requirements

I wanted three things:

Enter debts — name, balance, APR, minimum payment
Compare both strategies — Snowball (smallest balance first) vs Avalanche (highest APR first) side by side
See the math — total interest, payoff timeline, monthly schedule

And one non-negotiable: no data leaves your browser. No sign-up, no upload, no server.

The Architecture (It's Just HTML)

index.html
├── <head>        → styles + Chart.js CDN
├── <body>
│   ├── Input form (debt table + budget)
│   ├── Strategy toggle (Snowball / Avalanche)
│   ├── Results section
│   │   ├── Summary cards
│   │   ├── Chart.js payoff chart
│   │   ├── Milestone timeline
│   │   └── Payment schedule table
│   └── FAQ section
└── <script>      → all JS logic

Single file. Deploy anywhere. Vercel in my case, but Netlify, GitHub Pages, or even a plain web server all work.

The JavaScript: Three Scenarios, One Engine

The core logic runs three scenarios on the same debt data:

function calculateAll(debts, monthlyBudget, strategy) {
  // Sort debts by strategy
  const sorted = [...debts].sort((a, b) => {
    if (strategy === 'snowball') return a.balance - b.balance;
    if (strategy === 'avalanche') return b.apr - a.apr;
    return 0; // minimum payment only
  });

  // Run the payoff simulation
  return simulatePayoff(sorted, monthlyBudget);
}

The simulatePayoff function runs month by month:

Calculate interest accrued on each debt
Apply minimum payments
Throw remaining budget at the target debt
When a debt is paid off, roll its payment to the next target
Record every month (balance, paid status, milestone)

function simulatePayoff(debts, monthlyBudget) {
  let month = 0;
  const schedule = [];

  while (debts.some(d => d.balance > 0) && month < 120) {
    month++;
    let remaining = monthlyBudget;

    // Accrue interest first
    debts.forEach(d => {
      d.balance += d.balance * (d.apr / 100 / 12);
    });

    // Find the target debt (first unpaid in sorted order)
    const target = debts.find(d => d.balance > 0);

    // Apply minimums
    debts.forEach(d => {
      const min = Math.min(d.minPayment, d.balance);
      d.balance -= min;
      remaining -= min;
    });

    // Throw remaining at target
    if (target && target.balance > 0 && remaining > 0) {
      const extra = Math.min(remaining, target.balance);
      target.balance -= extra;
    }

    schedule.push({ month, debts: debts.map(d => ({ ...d })) });
  }

  return schedule;
}

The trick: run this three times — once for Minimum Only (no extra payments), once for Snowball, once for Avalanche. Then compare the results side by side.

The Chart: Chart.js with Dynamic Data

I used Chart.js (CDN-loaded) for the payoff timeline:

function renderChart(snowballData, avalancheData) {
  const ctx = document.getElementById('payoffChart').getContext('2d');

  new Chart(ctx, {
    type: 'line',
    data: {
      labels: snowballData.map(d => `Month ${d.month}`),
      datasets: [
        {
          label: 'Snowball',
          data: snowballData.map(d => d.totalRemaining),
          borderColor: '#059669',
          tension: 0.3
        },
        {
          label: 'Avalanche',
          data: avalancheData.map(d => d.totalRemaining),
          borderColor: '#2563EB',
          tension: 0.3
        }
      ]
    },
    options: {
      responsive: true,
      plugins: {
        legend: { position: 'top' }
      }
    }
  });
}

Two lines. Same starting point. The visual difference in payoff speed is immediately obvious.

The Result: Snowball vs Avalanche in One View

After running all three scenarios, the user sees:

Metric	Minimum Only	Snowball	Avalanche
Total Paid	$28,124	$26,686	$26,496
Total Interest	$3,424	$1,986	$1,796
Payoff Time	3 yrs 10 mo	1 yr 11 mo	1 yr 11 mo
Money Saved	—	$1,438	$1,628

Both strategies cut payoff time by half compared to minimum payments.

Key Takeaways for Devs

You don't need a framework. A single HTML file with vanilla JS can be a full product.
Client-side calculations are underrated. No server costs, no privacy concerns, no sign-up friction.
Side-by-side comparison sells itself. Showing the difference is more convincing than telling it.
Deploy in 2 minutes. Vercel, Netlify, GitHub Pages — pick one, drag your file, done.

The entire project from idea to deployment took about 6 hours. Cost: $0.

Try It or See the Code

🔗 Live tool: https://inisyght.online/debt-calculator

The full source is a single HTML file. View source in your browser — all the logic is right there, commented and readable.

Built with ☕ and a stubborn refusal to sign up for yet another SaaS.