DEV Community: a353551071

I forked an open-source game wiki template — the hard part was keeping it correct

a353551071 — Thu, 27 Aug 2026 01:57:12 +0000

Every game wiki has the same failure mode, and it isn't hosting or search — it's rot. A roguelite ships a balance patch, the "best build" everyone recommends gets quietly nerfed, and the wiki keeps presenting last month's meta as truth. Players burn a run on stale advice, blame the site, and never come back.

Sephiria is a new action roguelite that patches every few weeks, which makes it a worst case for wiki rot. So when I built sephiriabuilds.xyz, I spent more time on the correctness pipeline than on the visual design. This post is the parts worth stealing.

Start from a template, then strip it honest

I started from AnvilWiki — an open-source Astro 5 game-wiki template (MIT). It gives you content collections, tag pages, breadcrumbs, sitemap, and a clean card layout out of the box, which saves a week of plumbing.

The first real job was deletion, not addition. The template ships with demo content for its original game — placeholder boss pages, a fake "video guides" section with a YouTube ID that doesn't exist, promo blocks for games the template never covered. All of it gone. A wiki that shows one piece of fabricated content teaches the reader that none of it can be trusted.

What survived the strip is what a wiki actually is: content collections for builds / weapons / guides, tags as a free secondary navigation layer, and per-page frontmatter I could extend.

Mechanism 1: every page carries the patch it was written against

Each piece of content declares the game version it targets:

---
title: "Biryuu Katana — Crit Build"
gameVersion: "1.0.25"
evidence: "video-verified"
lastModified: "2026-08-26"
---

gameVersion renders as a version badge next to the title; lastModified renders in a trust bar under it. A reader landing from search can immediately see "written for 1.0.25, updated three days ago" versus "written for 1.0.18, untouched for a month" — which, for a game that patches monthly, is the difference between advice and archaeology.

This also disciplines me as the author. When a patch lands, I don't "refresh the site"; I open the pages whose mechanics the patch notes touched, bump their version stamp, and leave everything else alone. The Sephiria builds hub and the weapon tier list are the most patch-sensitive pages, so they get reviewed every time; a beginner guide explaining core mechanics rots much slower and is reviewed far less often.

Mechanism 2: grade the evidence, don't just cite it

Build guides have an evidence problem: half of what circulates on Reddit and YouTube is one player's opinion from two patches ago. So every recommendation on the site carries an explicit evidence grade:

video-verified — someone demonstrated it on camera in the current patch
community-reported — multiple independent players claim it works, no video yet
tested-this-patch — I reproduced it myself
carried-over — verified in an older patch, not yet re-tested after balance changes

This has a nice property: the grade is a to-do list. Anything sitting at carried-over after a balance patch is exactly the page that needs attention next.

Mechanism 3: make re-crawl instant

When a patch drops and I update pages, I want search engines back the same day, not in three weeks. Three boring pieces of plumbing do that:

Static generation. The whole site is SSG — a patch update is one rebuild, deploy takes seconds, and there's no server state to worry about.
Sitemap lastmod wired to lastModified. Not a static build date — the actual content date, so crawlers see which URLs genuinely changed.
IndexNow. After each deploy, a tiny script pings the updated URLs to IndexNow (Bing, Yandex, and friends), which accepts them within seconds. No quota anxiety, no waiting for organic re-crawl.

What I'd tell past me

Launch thin, launch honest. The site went live with four hand-written pages — a best-builds comparison, a tier list, a beginner guide, and one deep weapon build page — each with version stamps and evidence grades, rather than forty half-finished stubs. For search, four real pages beat forty hollow ones.
The template saves you a week of plumbing, not a week of judgment. The demo content, the fake sections, the "works for any game" defaults — deleting all of it was the product decision.
Design for the patch, not the launch. Every mechanism above exists because the game changes monthly. If your content has a shelf life, build the expiry date into the page itself.

The site is live and growing a few pages a week. Too early for traffic numbers — but the pipeline means that when a patch lands at 10am, the wiki is correct again by lunch.

I built a free dividend calculator suite (no signup, open-source math)

a353551071 — Sun, 23 Aug 2026 02:45:59 +0000

Every "free" dividend calculator I tried wanted an email, a signup, or a trial. The math behind all of them is public — yield, payout ratio, reinvestment compounding — so I built a dividend payout calculator that's actually free, runs entirely in the browser, and open-sources the engine.

What's in it

A suite of focused calculators rather than one mega-tool:

Dividend yield + payout ratio — the two-number sustainability check.
DRIP calculator — year-by-year reinvestment with a results table and chart.
Monthly dividend calculator — work backwards from the monthly income you want to the capital required.
Dedicated ETF calculators for SCHD (quarterly dividend growth) and QQQI (monthly income) — plus a live QQQI dividend calendar with recent distributions and the next projected ex-dividend date.

No account, no paywall, no "trial expired." It's a static site — the math is client-side.

The engine: a tiny open-source library

The interesting part was never the UI — it was the math. So I pulled every formula into one zero-dependency TypeScript library: dividend-math.

import {
  dividendYield,
  payoutRatio,
  monthlyDividendIncome,
  dripCalculator,
} from 'dividend-math';

A few engineering choices worth calling out:

Pure functions everywhere. Every formula is a pure function with no I/O — dividendYield, payoutRatio, monthlyDividendIncome, dripCalculator. That makes the edge cases (zero price, zero earnings, the g = 0 branch in the cumulative-dividend geometric series) easy to pin down with 16 unit tests.
One source of truth. The same dripCalculator drives the DRIP page, the SCHD and QQQI ETF calculators, and the monthly-income page. One implementation, no drift between pages.
Plain-number inputs. Percentages are plain numbers (5 for 5%), money is dollars. Bad inputs fail loudly (NaN) instead of returning plausible-looking nonsense.
Static, no backend. It's a statically-generated site — all computation happens in your browser, nothing is sent anywhere. Which is also why it can be free and sign-up-free forever.

Why open-source it

Two reasons. First, the math is commodity knowledge — yield, payout, reinvestment — there's no secret sauce to hoard. Second, open-sourcing it is the credibility move for a finance tool: you can read exactly what the calculator is doing instead of trusting a black box. The library is on npm (npm install dividend-math) and the source is up: github.com/a353551071/dividend-math, MIT.

Try it

App: dividendpayoutcalculator.com
Library (npm): npm install dividend-math
Source: github.com/a353551071/dividend-math

Engineering / showdev post, not financial advice. The calculators model scenarios; they don't recommend securities.

If you've got feedback — a calculator that's missing, a model you'd extend (tax drag? FX? yield-on-cost columns?) — I'd genuinely like to hear it. Building in public.

What's a "good" dividend yield? You need a second number

a353551071 — Fri, 21 Aug 2026 03:46:54 +0000

Ask "is this a good dividend yield?" and you've already asked half a question. Yield on its own is a ratio — annual dividend ÷ price — and a ratio can move for two very different reasons: the dividend went up, or the price went down. A crashing price inflates the yield and makes a deteriorating company look like a bargain.

To read a dividend you need a second number: the payout ratio — dividend ÷ earnings. That's the sustainability check. The two together are what I built the dividend yield calculator and payout ratio calculator to show side by side. Both run off the same open-source library, dividend-math.

Two functions, two different questions

import { dividendYield, payoutRatio } from 'dividend-math';

// Yield: income relative to the price you pay
dividendYield({ annualDividendPerShare: 2.8, price: 80 }); // → 3.5 (%)

// Payout ratio: dividend relative to what the company actually earns
payoutRatio({ dividendPerShare: 2, earningsPerShare: 5 }); // → 40 (%)

dividendYield tells you the cash flow per dollar invested. payoutRatio tells you whether that cash flow is actually affordable. One without the other is a story half-told.

Reading the pair

7% yield at a 95% payout ratio — the dividend eats almost everything the company earns. No room to grow it, and any earnings dip puts the payout at risk. The high yield is often the market pricing in a cut.
3.5% yield at a 40% payout ratio — modest income, but the dividend is covered two-and-a-half times over. There's headroom to raise it (which is how a 3.5% payer becomes a 6% yield-on-cost over a decade), and the payout survives a bad year.

Same headline yield, opposite stories. The payout ratio is the lie detector. That's why a "good" yield for something you intend to hold is usually in the 3–5% range with a healthy payout ratio — boring, sustainable, and able to grow — rather than a double-digit yield propped up by an unsustainable payout or a collapsing share price.

Pure functions, tested edges

Both are pure functions: dividendYield returns NaN for a zero price (fail loud, don't return a pretty Infinity), payoutRatio returns NaN for zero earnings. Edge behavior is pinned by unit tests, and the same functions drive every calculator page on dividendpayoutcalculator.com — yield, payout, growth, DRIP, SCHD, and the QQQI dividend calculator. One implementation, no drift.

Run it

Dividend yield calculator + payout ratio calculator — pair them, no sign-up.
Library (npm): npm install dividend-math
Source: github.com/a353551071/dividend-math (MIT)

Math/engineering post, not financial advice. Payout ratios differ by sector (REITs, MLPs run high legitimately); model scenarios, don't pick tickers.

What payout-ratio threshold do you treat as a yellow flag — 60%, 75%, higher for certain sectors? Always found the sector-dependence is where the simple rules break down.

How much do you need to earn $1,000 a month in dividends?

a353551071 — Wed, 19 Aug 2026 03:59:31 +0000

Most dividend calculators go forward: "I have $X, what do I get?" The question people actually obsess over is the inverse: "I want $1,000 a month in dividends — how much do I need?" That's a one-line formula, and the answer is where a lot of bad decisions start.

I built a monthly dividend calculator around exactly that inverse, powered by the open-source library dividend-math.

The inverse, in one line

Capital needed = (target monthly income × 12) ÷ yield.

// Solve for the capital that throws off a target monthly income at a given yield
const capitalFor = (monthlyIncome: number, yieldPct: number) =>
  (monthlyIncome * 12) / (yieldPct / 100);

capitalFor(1000, 4);   // → 300,000
capitalFor(1000, 6);   // → 200,000
capitalFor(1000, 13);  // → ~92,308

And going the other direction — the library's actual function — gives you the monthly income on a real position:

import { monthlyDividendIncome } from 'dividend-math';

monthlyDividendIncome({ investment: 300000, dividendYieldPct: 4 }); // → 1,000/month

Pure function, plain-number inputs (4 for 4%), money in dollars. Same formula on both sides of the equals sign.

The trap in the formula

Look at the three outputs above. The capital you "need" drops fast as the yield rises — $300k → $200k → $92k. So the formula whispers the same thing to everyone: just chase a higher yield and you can retire on less.

That's the trap. The yield that lets you hit the number with less capital is the yield carrying the most risk — an unsustainable payout, a price that's been collapsing (yield = dividend ÷ price, remember), or an option-income fund eroding its own NAV (run a covered-call monthly payer through the QQQI dividend calculator and you'll see how variable that "monthly" number really is). The monthly dividend calculator on dividendpayoutcalculator.com deliberately shows the income and the payout ratio together, because a monthly number you can't trust is worse than a smaller one you can.

The honest version of the formula: pick a yield you'd actually trust for a decade (often 3–5% for growth payers), and accept the capital that requires. Bending the yield to fit a smaller bankroll is working backwards from the wrong variable.

Run it

Live monthly dividend calculator: work backwards from the income you want, no sign-up.
Library (npm): npm install dividend-math
Source: github.com/a353551071/dividend-math (MIT)

Math post, not financial advice. "Monthly income" targets look tidy in a spreadsheet; real yields fluctuate and payouts get cut. Model scenarios, don't pick tickers.

What yield do you assume when you do this back-of-the-envelope — a conservative 3.5%, or do you let a high-yield fund do the heavy lifting? Curious where people actually land.

Yield on cost — the dividend metric DRIP quietly builds

a353551071 — Sun, 16 Aug 2026 14:01:59 +0000

Everybody quotes current yield — annual dividend ÷ today's price. It's the headline number. It's also the wrong number to watch once you actually own a position and reinvest. The number reinvestment grows is yield on cost: annual dividend ÷ what you originally paid.

A DRIP calculator makes this visible in a way a brokerage statement doesn't. The engine is the same open-source library, dividend-math.

What reinvestment actually does

dripCalculator simulates a dividend reinvestment plan year by year: dividends computed at the current yield on the current share count, reinvested into more shares at the current price, with both price and dividend growing each year.

import { dripCalculator } from 'dividend-math';

const r = dripCalculator({
  initialInvestment: 10000,
  price: 80,
  dividendYieldPct: 3.5,
  dividendGrowthPct: 10,
  priceGrowthPct: 7,
  monthlyContribution: 100,
  years: 20,
});

// The number nobody quotes: yield on cost
const yieldOnCost = (r.finalAnnualDividendIncome / r.totalInvested) * 100;

The interesting move is that last line. totalInvested is what you actually put in (initial + contributions). finalAnnualDividendIncome is what the position throws off per year at the end. Divide them and you get the yield on your original dollars — and after 15–20 years of dividend growth plus reinvestment, that number regularly runs two to three times the starting yield.

Why it climbs

Two forces, both quiet:

The dividend grows. A 3.5% payer raising its dividend ~10%/yr nearly triples the per-share dividend in a decade.
Reinvestment buys more shares at prevailing prices, and those shares then pay the (growing) dividend too.

Current yield can stay flat the whole time — the price rises alongside the dividend — while yield on cost keeps climbing, because the denominator is your historical cost, not today's price. That's the real return a long-term DRIP creates, and it's invisible if you only look at current yield.

The edge case worth getting right

Cumulative dividends over N years are a geometric series: D + D(1+g) + D(1+g)² + …. When g = 0 it collapses to D × N; when g > 0 it's the closed-form (D·((1+g)ᴺ−1))/g. The g = 0 branch has to be handled separately — divide by zero otherwise. It's the kind of thing that's easy to get subtly wrong, which is why every formula in the library is a pure function covered by unit tests. Same dripCalculator drives the DRIP, SCHD, QQQI, and monthly pages on dividendpayoutcalculator.com — one implementation, no drift.

Run it

Live DRIP / dividend reinvestment calculator: year-by-year table + chart, no sign-up.
Library (npm): npm install dividend-math
Source: github.com/a353551071/dividend-math (MIT)

Math/engineering post, not financial advice. Past dividend growth doesn't guarantee future growth; model scenarios, don't pick tickers.

How do you track yield on cost in your own portfolio — spreadsheet column, or do you let the broker's cost basis do the work? Always felt like a metric more people should watch.

The math of a monthly dividend ETF (QQQI), in TypeScript

a353551071 — Tue, 11 Aug 2026 14:14:01 +0000

Most dividend ETFs pay quarterly. QQQI pays monthly, and at a yield up in the low-double digits — it's a covered-call fund, so a chunk of that distribution comes from option premiums, not pure dividends. That combination — monthly cadence, high yield, options-derived income — makes the math interesting in a very different way than a plain growth payer like SCHD.

I built a dedicated QQQI calculator to make the tradeoffs visible, powered by the same open-source library: dividend-math.

Why "monthly" changes the compounding

Reinvestment frequency matters. The more often you reinvest, the sooner each reinvested cent starts earning. A monthly payer gives you 12 reinvestment points a year instead of 4. Same annual rate, more frequent compounding — the gap is small in year one and meaningful over a decade.

The monthly-income side is a single pure function:

import { monthlyDividendIncome } from 'dividend-math';

// $50,000 in a ~13% monthly payer
monthlyDividendIncome({ investment: 50000, dividendYieldPct: 13 }); // → ~541.67/month

And the longer horizon uses dripCalculator, which reinvests year by year:

import { dripCalculator } from 'dividend-math';

const result = dripCalculator({
  initialInvestment: 50000,
  price: 50,
  dividendYieldPct: 13,
  dividendGrowthPct: 0,   // high option-yield funds don't *grow* the dividend much
  priceGrowthPct: 2,      // …and price upside is capped by the call side
  monthlyContribution: 0,
  years: 10,
});

Notice the inputs that tell the real story: a high yield paired with low growth. That's the structural difference between an options-income fund and a dividend-growth fund.

The part the yield number hides

A 13% monthly yield is a great headline. But for a covered-call fund, two things drag on it: the dividend barely grows (you're selling upside for income), and the net asset value can erode if the option strategy underperforms in strong rallies. So the "monthly income" looks lush while the principal may not compound the way a growth payer's does.

This is exactly why the QQQI calculator on dividendpayoutcalculator.com shows the income and the projected value side by side — so you can't fall in love with the monthly number without seeing what's happening to the base.

The honest framing: a monthly payer is an income tool, not a compounding engine. Different job than SCHD. The math makes that obvious once you model both.

Pure functions, one library

monthlyDividendIncome, dripCalculator, dividendYield, payoutRatio — all pure functions, all edge-tested (unit tests). One library drives every calculator page on the site, so the monthly income on the QQQI page is the same formula as anywhere else.

Live QQQI calculator: dividendpayoutcalculator.com/.../qqqi-dividend-calculator
Library (npm): npm install dividend-math
Source: github.com/a353551071/dividend-math (MIT)

Engineering + math post, not financial advice. Option-income funds have real NAV and tax complexities — model scenarios, don't pick tickers from a blog.

For the high-yield folks: how do you model the NAV-erosion drag in a reinvestment sim — flat haircut on the yield, or a price-growth assumption below the index? Genuinely curious what's worked in your models.

Modeling SCHD's dividend growth, in TypeScript

a353551071 — Sun, 09 Aug 2026 11:43:11 +0000

SCHD (Schwab's U.S. Dividend Equity ETF) shows up on every "best dividend ETF" list, but rarely for the reason that actually matters: its dividend grows. The starting yield is modest — somewhere in the 3–4% neighborhood — yet SCHD has raised its dividend on the order of ~10–12% per year over its life. That's the whole game. A flat 6% yield pinned to a share count that never moves eventually gets lapped by a 3.5% yield that grows and compounds.

I wanted to make that math tangible, so I built a dedicated SCHD dividend calculator — and the engine behind it is the same tiny TypeScript library I open-sourced: dividend-math.

The model

The core is one pure function, dripCalculator, that simulates year by year:

Dividends at the current yield on the current share count.
Reinvest those dividends into more shares at the current price.
Grow the price by priceGrowthPct, and — the part that matters for SCHD — grow the dividend itself by dividendGrowthPct.

import { dripCalculator } from 'dividend-math';

// A SCHD-shaped scenario: modest starting yield, meaningful annual dividend growth
const result = dripCalculator({
  initialInvestment: 10000,
  price: 80,
  dividendYieldPct: 3.5,
  dividendGrowthPct: 11,   // SCHD's dividend has grown ~10-12%/yr historically
  priceGrowthPct: 9,
  monthlyContribution: 0,
  years: 15,
});
// → { shares, finalPrice, finalValue, totalInvested, totalDividends, finalAnnualDividendIncome }

The numbers above are illustrative — a SCHD-shaped profile, not a forecast. SCHD pays quarterly, and the live calculator handles the quarterly cadence and lets you plug in real figures. The point of the model is the shape, not the decimals.

Why growth beats a fat yield

The result that surprises people: after 15 years the annual dividend income on that position is several multiples of year one — not because the yield is high, but because the dividend grew ~11% a year and every reinvestment bought shares that then threw off more dividend.

This is why a "good" yield for a holding you intend to keep is usually 3–5%, not 8%+. A yield that high often means the price collapsed (yield = dividend ÷ price, so a crashing price inflates the yield) or the payout is unsustainable. SCHD's appeal is the opposite: a moderate, growing dividend funded by real earnings.

That's also why the calculator pairs yield with the payout ratio — a high yield you can't trust is worse than a lower one you can.

Pure functions, one source of truth

Every formula is a pure function — dividendYield, payoutRatio, dripCalculator — so the edge cases (zero price, zero growth, the geometric-series term when growth is zero) are pinned down by unit tests. The same dripCalculator drives the DRIP page, the SCHD and QQQI ETF calculators, and the monthly-income page on dividendpayoutcalculator.com. One implementation, no drift between pages.

Run it

Live SCHD calculator: dividendpayoutcalculator.com/.../schd-dividend-calculator — real quarterly cadence, no sign-up.
Library (npm): npm install dividend-math
Source: github.com/a353551071/dividend-math (MIT)

This is a math/engineering post, not financial advice. Dividends aren't guaranteed and past growth doesn't predict future results — use the calculator to model scenarios, not to pick tickers.

Anything you'd add to the model — tax drag, yield-on-cost tracking, variable contribution timing? Curious how you'd extend it.

I open-sourced the math behind my dividend calculator

a353551071 — Sat, 08 Aug 2026 11:57:05 +0000

When I built a free dividend payout calculator, the interesting part wasn't the UI — it was the math. Dividend yield, payout ratio, and especially the way a DRIP (dividend reinvestment plan) compounds year over year. So I pulled the formulas out into a tiny, zero-dependency TypeScript library: dividend-math.

This post is the story of the library and the one calculation that surprised me: how reinvestment plus growth quietly outruns a flat high yield.

The library

dividend-math is one file of pure functions. No runtime dependencies, no I/O, fully tree-shakeable. You can npm install dividend-math or just copy src/dividend.ts into your project.

import {
  dividendYield,
  payoutRatio,
  monthlyDividendIncome,
  dripCalculator,
} from 'dividend-math';

// Yield: $2.80 annual dividend on an $80 share
dividendYield({ annualDividendPerShare: 2.8, price: 80 }); // → 3.5 (%)

// Sustainability: dividend vs earnings
payoutRatio({ dividendPerShare: 2, earningsPerShare: 5 }); // → 40 (%)

// Monthly cash flow on a position
monthlyDividendIncome({ investment: 50000, dividendYieldPct: 13 }); // → ~541.67/month

All percentage inputs are plain numbers (5 for 5%); money is in dollars. Returns are numeric and predictable — dividendYield returns NaN for a zero price, payoutRatio returns NaN for zero earnings, so the bad inputs fail loudly instead of producing pretty-looking nonsense.

The interesting one: DRIP compounding

dripCalculator simulates a dividend reinvestment plan year by year. Each year it:

Computes dividends at the current yield on the current share count.
Reinvests those dividends into more shares at the current price.
Adds monthly contributions buying shares at the current price.
Then grows the price by priceGrowthPct and the yield by dividendGrowthPct.

const result = dripCalculator({
  initialInvestment: 10000,
  price: 80,
  dividendYieldPct: 3.5,
  dividendGrowthPct: 10,
  priceGrowthPct: 7,
  monthlyContribution: 100,
  years: 15,
});
// → { shares, finalPrice, finalValue, totalInvested, totalDividends, finalAnnualDividendIncome }

The result that always gets people: a 3.5% yield with 10% annual dividend growth, reinvested, beats a flat 6% yield over a long horizon — because the dividend grows and buys more shares as it does. The starting yield is the wrong number to optimize; the growth rate matters more.

That's the whole reason a "good" dividend yield is usually 3–5%, not 8%+. A high yield often means the price collapsed or the payout is unsustainable — which is why the calculator pairs yield with the payout ratio.

Why pure functions, and why a library at all?

Two reasons. First, testability: every formula is a pure function, so the edge cases (zero price, zero growth, g = 0 in the geometric series for cumulative dividends) are covered by 16 unit tests. Second, reuse: the same dripCalculator drives the DRIP page, the SCHD and QQQI ETF calculators, and the monthly-income page on the live site. One source of truth, no drift.

The live calculator

The library powers dividendpayoutcalculator.com — a free suite with dedicated calculators for SCHD and QQQI, plus yield, payout ratio, growth, and monthly income. No sign-up, runs entirely in the browser.

If you're building anything finance-adjacent and need the math, grab the library. If you just want to run the numbers, the calculator's free.

Library (npm): npm install dividend-math
Source: github.com/a353551071/dividend-math (MIT)
Live app: dividendpayoutcalculator.com

Thoughts on the DRIP model — anything you'd add to the simulation (tax drag, FX, variable monthly contributions)? I'd love to hear how you'd extend it.