DEV Community: Tasleem Akhtar (#Ch)

UPPERCASE, camelCase, kebab-case — Every Text Case Explained With One Example

Tasleem Akhtar (#Ch) — Sun, 04 Oct 2026 09:55:56 +0000

Every developer, marketer, and student eventually pastes text into a case converter at 11pm — usually after pasting it into a Word document first and feeling vaguely dirty about it. The tool seems trivial. It isn't, for two reasons: each case has a specific job, and two of them have traps that surprise people who've used them for years. Here's the whole family, using one example phrase throughout.

One input, eight outputs

Take wedding gift amount calculator through every standard mode:

Mode	Output	Used for
UPPERCASE	WEDDING GIFT AMOUNT CALCULATOR	Headlines, warnings, acronyms
lowercase	wedding gift amount calculator	Cleanup, casual brands
Title Case	Wedding Gift Amount Calculator	Headings, article titles
Sentence case	Wedding gift amount calculator	Body text, subtitles
camelCase	weddingGiftAmountCalculator	JavaScript variables
snake_case	wedding_gift_amount_calculator	Python, Ruby, SQL columns
kebab-case	wedding-gift-amount-calculator	URLs, CSS classes, file names
CONSTANT_CASE	WEDDING_GIFT_AMOUNT_CALCULATOR	Python/JS constants, env vars

The URL row is worth internalizing: search engines treat hyphens as word separators, so kebab-case slugs are the SEO-correct choice — underscores technically concatenate words for Google's tokenizer. Paste any phrase into a slug generator if you also want stop-words stripped.

The two Title Case traps

Trap 1 — small words. Most converter engines (this includes the simple ones and several big-name tools) capitalize every word: "The Lord Of The Rings" instead of "The Lord of the Rings." Chicago and AP style lowercase articles and short prepositions mid-title. Neither is wrong — news headlines capitalize everything, book titles don't — but know which convention you're shipping, and hand-fix the five small words when a style guide is watching.

Trap 2 — accents. Title-case logic usually keys on ASCII word boundaries, so "éclair理论" style words starting with accented letters can keep a lowercase first letter after conversion. UPPERCASE and lowercase modes handle all Unicode fine (café → CAFÉ just works). If your text is multilingual, convert with upper/lower and spot-check the title output.

Why "free download" tools are the wrong instinct

People still search for a case converter free download — an executable, for changing letter case. It's worth being blunt about why browser tools won: nothing to install, nothing that lingers in your registry, works on the office laptop where you can't install software, and your text never leaves the machine (the conversion happens in JavaScript in your tab). A good one keeps working offline once loaded. Bookmark the tab; it outlives every .exe you'd have downloaded. Our case converter does all eight modes live with a single paste — and it's the kind of utility that pairs well with the rest of a browser toolkit rather than a bloated suite install.

Which case belongs where — the short version

Body paragraphs: Sentence case. Always. ALL-CAPS PARAGRAPHS read as shouting and measurably reduce reading speed.
Headlines: Title Case for articles and blog posts; UPPERCASE sparingly for ad copy — past about six words, caps become noise.
Code: match your language's convention — camelCase in JavaScript, snake_case in Python, CONSTANT_CASE for true constants. Consistency beats preference.
URLs and file names: kebab-case, lowercase, hyphens over underscores.
Email subjects: Sentence case converts better than ALL CAPS in every A/B test you'll find public data for; caps correlate with spam filters too.

One workflow that saves real time

Reformatting a whole document? Convert first, then run the before/after through a text diff checker to confirm only case changed — it catches the accidental deletes and double-spaces that case-cleanup sessions invite. And if the brief has length limits (meta descriptions, ad headlines), a word counter closes the loop.

The humble case converter earns its place the same way every good micro-tool does: it removes a thirty-second task you'd otherwise do by hand a hundred times a year, and it does it without becoming a subscription.

The Coin Flip Is the Most Underrated Decision Tool in History (Here's the Math)

Tasleem Akhtar (#Ch) — Sat, 03 Oct 2026 17:58:17 +0000

Two people, one decision, zero preference between the options. The oldest tiebreaker on earth is still the best one — not because the coin is magical, but because of what it does to the argument. Let's look at why flipping works, how to run it fairly for named people, and the streak math that will make you stop saying "that coin is broken."

Why the coin flip beats deliberation at 50/50 decisions

The productive insight isn't statistical, it's psychological: when you're genuinely indifferent, the flip's value is speed. When you're secretly not indifferent, the flip's value is revelation — the half-second while the coin is in the air is the only honest moment of the whole process, because that's when you notice which side you're hoping for. Psychologists have formalized this as the "coin flip probe" for detecting latent preferences. Either outcome helps.

The engineering requirement is simple: the flip must be actually fair. A coin you toss yourself has subtle dynamics (coin-catching on the back of the hand, the Danny Kahneman story aside, is close to fair; coin-spinning on a table is measurably biased toward the heavier face landing down). Digital flips with a proper random source avoid the biomechanics entirely.

Assign names before the flip, not after

For two people the protocol is one sentence long: "Heads is Ali, tails is Sara, winner takes the window seat" — said out loud, then flip. The announcement is not ceremony; it's the entire fairness mechanism. Reassigning sides after seeing a result is how people accidentally (or deliberately) rig draws, which is why formal competitions lock mappings first.

For three or more names, coins need structure:

Bracket method: A vs B flip, winner vs C flip. Fair per flip, but early positions get a structural edge in some brackets.
N-way draw: assign each name a number and draw 1–N once. No positional artifact. (A random number generator does this cleanly for any N.)

Best-of-3 is still exactly 50/50 — here's why

Intuition says "best of 3 gives someone more chances." It doesn't. If each flip is 50/50, both players' series-win probability is identical by symmetry — the series just has higher variance, meaning the weaker luck has more room to express itself, not more chance to win. Best-of-5, best-of-7, best-of-101: still 50/50. Series length changes how long the drama runs, never who's favored. (The moment players differ in skill, this all changes — but coin flips have no skill component, which is the point.)

The streaks you'll actually see

This is where most people's intuition breaks, so here are the numbers:

Event	Probability	In practice
3 heads in a row	1/8 = 12.5%	About once every 8 single flips
5 heads in a row	1/32 ≈ 3.1%	Every ~32 flips — normal, not "rigged"
10 heads in a row	1/1,024 ≈ 0.098%	About once per thousand-flip session
1,000 flips, head count	500 ± 16	68% of sessions land between 484 and 516

That last row is the important one. The standard deviation of 1,000 fair flips is √(1000 × 0.5 × 0.5) ≈ 15.8, so landing at 517 heads is not evidence of bias — it's one standard deviation plus a rounding error. Run a crypto-random coin flip a thousand times (it has a batch mode with running stats) and you'll watch the percentage converge toward 50/50 while never once landing exactly there. Convergence without precision is exactly what real randomness looks like; if the split were always 500/500, that would be suspicious.

What "crypto-random" actually means

Browser-based flips that call crypto.getRandomValues use the same entropy source browsers use for generating encryption keys — hardware-seeded, continuously stirred, nothing like the predictable Math.random() of old scripts. You can't practically bias it, and unlike a physical coin there's no spin technique to master. For draws where someone will absolutely accuse you of cheating (chores, who chairs the meeting, fantasy football draft order), "cryptographic" is the word that ends the conversation.

The takeaway

The coin flip survived five thousand years because it does three jobs at once: it's fast, it's fair, and it's honest about indifference. Run it with a locked name mapping, trust best-of-N to stay 50/50, and forgive the five-head streaks — the math says they're supposed to happen. And when the decision involves more than two names, skip the bracket drama and draw numbers once.

Etsy Fees Decoded — Exactly What a $25 Sale Puts in Your Pocket

Tasleem Akhtar (#Ch) — Sat, 03 Oct 2026 12:15:56 +0000

You list a print for $25. It sells. The buyer pays $30 with shipping. Etsy shows a cheerful deposit notification — and then quietly removes $3.30 before the money ever reaches your bank. That number isn't a mystery, but Etsy's help docs spread it across six pages, so most sellers price by vibes and discover the margin afterwards. Here's the whole stack in one place, with real math.

The four fees, in order of pain

1 — Listing fee: $0.20. Charged per listing, renewable every four months, payable whether the item sells or not. It's the fee everyone knows because it's the only one you pay upfront.

2 — Transaction fee: 6.5% — and this is the line that catches people — applies to item price plus shipping. Charge $5 shipping and Etsy takes 32.5 cents of it. Your shipping money is not your money.

3 — Payment processing: 3% + $0.25 in the US (the percentage varies by country; the flat fee doesn't). Again on item + shipping. The flat $0.25 is what makes cheap items proportionally expensive to sell — on a $4 sticker, processing alone eats 9%.

4 — Offsite Ads: 12% of item + shipping, applied only when the buyer clicked an Etsy-placed external ad. For shops over $10,000 in trailing-year sales this is mandatory; smaller shops can opt in. It's also the reason one random Tuesday order can come with a surprise $3.60 haircut.

The $25 sale, on paper

Item $25, shipping $5, product cost $8, shipping cost $4, no Offsite Ads hit:

Line	Math	Amount
Transaction fee	$30 × 6.5%	$1.95
Payment processing	$30 × 3% + $0.25	$1.15
Listing fee	flat	$0.20
Total Etsy fees		$3.30
Revenue after fees	$30 − $3.30	$26.70
Net profit	$26.70 − $8 − $4	$14.70

That's a 49% margin — perfectly workable. But notice what would have happened if the buyer came from Offsite Ads: +$3.60 (12% of $30), net drops to $11.10, margin to 37%. One ad-attributed sale wipes the fee difference of roughly nine ordinary ones. This is why sellers who ignore attribution data think their "good weeks" feel randomly thin.

Digital products change the math dramatically

A $12 downloadable has no shipping, so the fee base shrinks to $12:

Transaction: 12 × 6.5% = $0.78
Processing: 12 × 3% + $0.25 = $0.61
Listing: $0.20
Total: $1.59 → net $10.41, an 87% margin with zero delivery cost

Even with an Offsite Ads hit (+$1.44), the digital net is $8.97 (75%). The structural advantage isn't just "no shipping cost" — it's that both percentage fees compute on a smaller base. If you're torn between physical and digital product lines, this asymmetry is the loudest argument for digital.

Pricing rules that survive contact with the fee stack

Rule 1 — fees + cost under 50% of revenue. At $25/$5 shipping, fees were 11% and cost was 40%: fine. If your cost hits 60%, no fee optimization saves you; the price is wrong.

Rule 2 — cheap items need bundles. The $0.25 flat processing fee is 6.25% of a $4 item and 0.83% of a $30 one. Selling $4 things individually is donating to the payment processor; bundle to $15+.

Rule 3 — include shipping in every mental calculation. The 6.5% + 3% + 12% stack all computes on item + shipping. A "free shipping" listing isn't fee-free shipping — you just moved the base into the item price, which is actually what you should do for conversion, but do it with eyes open.

Rule 4 — check your actual margin per product, not per shop. A 50% average with one hero product at 70% and three duds at 15% is a business problem disguised as a success story.

Compute before you list, not after you sell

We built a free Etsy fee calculator that runs this exact stack — enter price, shipping, costs, tick the Offsite Ads box if you want the mandatory-tier scenario, and it shows every line plus your net and margin percentage. There's a profit margin calculator for cross-product analysis, an invoice generator for the bookkeeping side, and an estimate generator for made-to-order quotes. The whole tool index is one page.

The fee stack never gets smaller — 2018 saw the transaction fee go from 3.5% to 5%, then to 6.5% in 2022. Sellers who price with the stack in mind treat every Etsy update as a pricing spreadsheet edit; sellers who don't, wonder each April where the year went.

How Much Should You Actually Give at a Wedding? The Etiquette Math, Solved

Tasleem Akhtar (#Ch) — Fri, 02 Oct 2026 20:28:18 +0000

Every wedding invitation comes with a silent question nobody answers out loud: how much cash goes in the envelope? Ask five people and you'll get five numbers ranging from "whatever's in your wallet" to a figure that equals your monthly rent. The group chat is no help — it just argues. So let's do what actually resolves it: turn the etiquette into a formula you can run in ten seconds, with numbers that hold up across regions and relationship levels.

The rule hiding behind all the advice

Strip away the conflicting articles and every serious etiquette source lands on three factors:

Closeness to the couple — a coworker you see at birthdays is not your cousin you grew up with.
Attendance — attending costs more than not attending, and bringing a guest roughly doubles your plate at the reception.
Regional norms — a cash envelope in Karachi runs very different from one in Chicago, and that's not stinginess, it's culture.

The working formula that captures all three:

Base amount × closeness multiplier × attendance multiplier = your range floor.
Range ceiling = floor × 1.5.

For US weddings the base sits near $50. Closeness runs: coworker ×1.0, friend ×1.3, close friend ×1.7, immediate family ×2.2. Attendance: solo ×1.0, with guest ×1.6 — that bump is the classic "cover your plate" rule, because your guest's meal genuinely costs the couple real money.

Worked rows you can check by feel

Relationship	Attendance	Math	Comfortable range
Coworker	Solo	50 × 1.0	$50 – $75
Friend	Solo	50 × 1.3	$65 – $100
Close friend	Solo	50 × 1.7	$85 – $130
Close friend	+ guest	50 × 1.7 × 1.6	$135 – $200
Immediate family	Solo	50 × 2.2	$110 – $165

Sanity-check that against the big annual wedding surveys (The Knot's guest-spending study being the usual reference) and the overlap is real: close ties cluster around $100–$200, distant ties under $100. The formula isn't inventing numbers — it's compressing thousands of people's instincts into arithmetic you can actually use for your situation.

And it ports across gift cultures with just a base change: Pakistan starts at ₨15,000, the Gulf at AED 200, India at ₹4,000, UK/EU at €40. Same multipliers, because closeness and attendance behave the same everywhere — only the money unit moves.

Three corrections people always make

Correction 1: the destination wedding discount. There isn't one. You bought the plane ticket because you wanted to be there; the envelope stays at your normal range. Etiquette treats travel cost and gift as separate line items, and every etiquette columnist agrees on this one.

Correction 2: rounding to "nice" numbers. Nobody hands over $87. The final number rounds to fives — the ranges above already account for that, which is why the guest row lands at $135, not $136.

Correction 3: affordability inversion. If the formula's floor breaks your budget, give the floor you can afford and show up generously. Presence outranks the envelope in every tradition that has an opinion on this. The formula is a ceiling-check for overspenders more than a quota for everyone else.

Run your own numbers in ten seconds

If you'd rather not do the multiplication at the dinner table, we built a free wedding gift amount calculator that runs exactly this logic — pick relationship, region preset, and solo/plus-one, and it shows the range plus the reasoning line underneath ("base $50 × closeness 1.7 × attendance 1.6"), because a number without its math is just another opinion.

It lives inside a wider calculator toolkit — the gift tax calculator matters once envelopes get genuinely large (US gifts above the annual exclusion count against the lifetime limit), and the gift idea finder handles the physical-present half of the dilemma. The full index of everything is here if you're the type to browse.

The one-line takeaway

Your envelope has a floor (base × closeness × attendance), a ceiling (×1.5), and zero obligation to exceed either. Do the math once, stop re-litigating it in the group chat, and spend the saved mental energy on actually enjoying the wedding — that's what the couple invited you for.

What "Runs Entirely in Your Browser" Actually Means: A Developer's Guide to Client-Side File Tools

Tasleem Akhtar (#Ch) — Wed, 16 Sep 2026 08:45:23 +0000

Most free online tool sites print some version of the same promise in their footer: "your files never leave your device." Some sites mean it. Some mean "we process it, trust us." The good news for developers: this is one of the few privacy claims you can personally audit in about a minute with DevTools, no vendor questionnaires required.

In this post I'll break down what the claim actually requires technically, walk through three categories of browser-side tools with real worked examples (including a compression test I ran specifically for this article), and give you a 60-second checklist for verifying any tool's claim yourself.

The spectrum: client-side, hybrid, server-side

Almost every "free online tool" falls into one of three buckets:

True client-side. Your file is read by the browser's File API, processed by JavaScript or WebAssembly running in the page, and handed back to you as a Blob download. The network is never touched during processing. Privacy here is a technical property, not a promise — you can watch it not happen.

Hybrid. Part of the job happens locally, part touches a server. A URL expander, for instance, must fetch the remote URL by definition. A downloader that pulls a video for you is making network requests to someone else's infrastructure. These tools can be perfectly legitimate, but "your files never leave your device" would be false advertising for them.

Server-side. The file is uploaded, processed on someone's server, and sent back. This is how many popular PDF utilities have traditionally worked. It's not automatically malicious — but it means your document transits and (transiently) exists on hardware you don't control.

The interesting category is the first one, because the mechanism is genuinely elegant. Let's look at three real examples.

Example 1: image compression with the HTML canvas

The humble <canvas> element can do something people rarely think about: decode an image, draw it, and re-export it at a chosen quality setting. That's the entire mechanism behind browser-based image compression — no server, no upload, just re-encoding pixels your browser already holds in memory.

I verified this against the copy on Toolfyra's free image compressor, whose FAQ states it plainly: "Compression uses the HTML canvas on your device — files never leave your browser." The tool accepts JPG, PNG and WebP input, and offers two modes:

a quality slider, where you pick a quality level and see what comes out, and
a target size mode, where you specify something like "under 100 KB" and the tool binary-searches the quality level until the output fits while keeping quality as high as possible. (Their FAQ describes exactly this: "It binary-searches the quality level to get under your KB limit with the highest possible quality.")

Why does quality matter so much? Because JPEG size is wildly sensitive to it. Here's a real test I ran for this article — Python's Pillow library, a noisy 2048×1536 test frame (noise compresses about as stubbornly as a detailed photograph):

Encoder setting	Output size	vs. q90
PNG (lossless, same frame)	9,229 KB	—
JPEG quality 90	2,528 KB	100%
JPEG quality 70	1,613 KB	64%
JPEG quality 50	1,174 KB	46%
JPEG quality 30	792 KB	31%

Dropping from q90 to q50 cut the file to less than half the size on this frame. Whether the visual loss is acceptable is a judgment only you can make for a given image — that's precisely why a slider plus a live preview beats a one-shot "compress" button.

The binary search for a target size is also nice little math. If quality runs from 0 to 100, log₂(100) ≈ 7 compression attempts are enough to pin the quality within ±1 of the largest value that fits your KB budget. When a job portal demands a photo under 100 KB, that's the difference between five manual "try and check" rounds and one click.

Example 2: merging PDFs with an in-browser library

For years, "merge PDF online" meant uploading your documents — sometimes a job application, sometimes a contract — to a stranger's server. The modern alternative: a library like pdf-lib running inside the page, which assembles PDFs locally.

Toolfyra's merge PDF page says it uses "PDF-LIB in your browser: files are never uploaded, which also makes it faster and private." The workflow is deliberately boring, which is what you want in a utility:

Add two or more PDFs (drag-and-drop or file picker) — they stay on the device.
Check the order. The page gives you ↑/↓ buttons per file rather than drag-to-reorder, which is honestly more reliable on a phone.
Merge. Files concatenate top-to-bottom in list order.
Download the combined PDF.

A concrete example: a job application needs cover letter, CV, and two certificate scans as one document. Add them in that order, merge, done — the combined file is assembled in browser memory from bytes that were never sent anywhere.

The honest limitations, straight from the same page's FAQ: there's no hard file-count limit, but "very large combined files may be slower on older phones." And merging is concatenation, not compression — if you need the output smaller, that's a different operation (and a different quality trade-off, as the table above shows).

Example 3: JSON formatting with the browser's own JSON engine

This one is almost mundane: JSON.parse() and JSON.stringify() are built into every browser. A JSON formatter is UI wrapped around them — but the UI is where the value is.

Toolfyra's JSON formatter and validator runs entirely with the browser's own JSON engine ("Is my API data sent to a server? No — parsing happens with your browser's own JSON engine, locally," per its FAQ). It beautifies at 2 spaces, 4 spaces, or tabs, minifies for production payloads, and — the part I actually care about — pinpoints syntax errors with a line and column.

Worked example. You pull a config from a service and it fails to load. The cause is a trailing comma:

{
  "service": "billing",
  "retries": 3,
  "timeout_ms": 2500,
}

A raw JSON.parse in your console gives you an error that's technically accurate and practically unhelpful. A good validator tells you where: line 5, the trailing comma after the last property. The same tool's FAQ lists the usual suspects it was built for — single quotes instead of double, trailing commas, unquoted keys, and Python-style True/False/None where JSON wants true/false/null. If you've ever pasted Python dict output into a JS context, you've hit all four.

The page is also upfront about scale limits: multi-megabyte payloads are fine, but beyond roughly 10 MB the browser may slow down. That's a fair and honest caveat — you're asking a UI thread to pretty-print a string.

The same pattern (browser-native engines, zero upload) covers a lot of ground beyond these three — Toolfyra's toolbox alone includes an OCR text extractor that recognizes text from images and PDFs on-device. The point isn't any one tool; it's that the pattern has matured.

The 60-second audit: verify any "client-side" claim yourself

Here's the checklist I use before pasting anything remotely sensitive into a web tool:

Open DevTools → Network tab before touching the tool. Clear the log.
Do the operation. Watch for POST requests whose body size grows with your file, upload progress bars, or requests to endpoints you didn't trigger. A genuinely local tool shows a quiet Network tab during processing.
The gold standard: go offline. After the page has loaded, switch DevTools to Offline throttling (or actually disconnect), then run the operation. If it still works, the computation was local. A server-side tool physically cannot pass this test.
View-source and search for fetch(, XMLHttpRequest, WebSocket. Endpoints that exist for analytics are normal; endpoints receiving your file content are not.
Read the privacy page — for the analytics, not the file handling. Processing locality and site analytics are two separate claims. Toolfyra, for example, runs Google Analytics behind a Consent Mode v2 banner that stays denied until you accept, while file processing happens locally. Those facts coexist; a page claiming both "zero analytics" and "free tools" deserves extra skepticism.

Honest caveats about the client-side model

To keep this article honest, the trade-offs:

Client-side ≠ anonymous. As above, analytics and file processing are separate layers. Judge them separately.
First loads are heavier. In-browser engines — OCR especially — can run to multiple megabytes on first download. After caching, it's fine — but it's a real cost.
Your hardware is the ceiling. Old phones are the constraint for big files, not some remote datacenter. That's the price of the files staying yours.
Some jobs genuinely need a server. Anything that must reach out to a third-party service on your behalf is hybrid by nature. The privacy claim to look for is precision: which part runs where.
"It didn't make network calls" is not a security audit. It's a point-in-time observation. For anything truly sensitive, the offline test plus a view-source scan is due diligence, not a guarantee.

Takeaways

"Runs in your browser" is a checkable technical claim: quiet Network tab, works offline after load.
Canvas re-encoding gives you real image compression locally, including automatic target-size search.
pdf-lib in the page makes PDF assembly a local operation — order files, merge, download.
The browser's own JSON engine plus good error UI beats most desktop utilities for everyday API debugging.
Use the offline test. It takes ten seconds and it's the closest thing to proof the Web offers.

None of this requires trusting my description of any tool — including the ones I linked. That's the whole point: the verification mechanism is on your side of the screen.

Some drafts were prepared with AI assistance and reviewed by the site team.

SRT Subtitles: The Timing Rules Editors Learn the Hard Way

Tasleem Akhtar (#Ch) — Tue, 15 Sep 2026 05:00:00 +0000

SRT is the friendliest subtitle format ever designed — plain text, four fields per cue — and yet badly-timed SRTs are everywhere. The rules that fix 95% of them fit on one screen.

Rule 1: Lead with the cut, not the sentence. A cue should land on the shot change or the first audible syllable, whichever the eye meets first. Cues that float 300 ms late read as lag even when the audio sync is perfect.

Rule 2: Two lines, ~42 characters, 17–20 chars/second. Reading speed is the physics of subtitles. A cue that needs three lines or a 25 cps sprint loses viewers at the second line; split it instead. Minimum duration ~1 second, maximum ~6–7 — beyond that, re-readers appear.

Rule 3: Gap between cues. A 2-frame gap (≈80 ms) between consecutive cues lets the eye register the change; wall-to-wall cues blur into one endless subtitle.

Rule 4: Timestamps are HH:MM:SS,mmm --> HH:MM:SS,mmm — the comma before milliseconds is the hill SRT parsers die on. Export tools that write a dot instead break half the players on earth. (Yes, really.)

Rule 5: Verify on the worst player you ship to. Smart TVs and old Android players disagree about line breaks and positioning; test the minimum, not the average.

Our in-browser generator (https://toolfyra.com/video-subtitle-generator.html) builds spec-correct SRT with these rules baked in — timing, gaps, comma format — and exports locally, so transcript drafts never leave your machine. For the surrounding pipeline, the video tools index lives at https://toolfyra.com/sitemap.xml.

Keeping 4,200 Static Pages Fast on Free Tiers: The Build Discipline That Makes It Boring

Tasleem Akhtar (#Ch) — Mon, 14 Sep 2026 05:00:00 +0000

Our site serves 4,200+ pages — tools, guides, blogs — with no backend, on free-tier hosting. It stays fast because we treat speed as a build property, not a tuning exercise. Five disciplines do the work.

1. Static until proven dynamic. Every page is pre-rendered HTML. The only "server logic" is edge caching. When a tool needs compute, the compute ships as WASM to the browser — the server's job stays zero.

2. One generator, disk-truth sitemaps. The sitemap is generated from the files that actually exist, never from a database that can drift. Our integrity audit (https://toolfyra.com/sitemap.xml is the machine-readable truth) runs after every deploy and fails the release on any URL/content mismatch. Boring is the goal.

3. Cache headers as architecture. Immutable assets get year-long caching with hashed or versioned paths; HTML gets short TTLs so releases propagate in minutes. The 35 MB ffmpeg core is served once per visitor, then silence.

4. Budget the heavy things on-origin vs CDN. WASM engines live same-origin for privacy and CSP simplicity; the truly huge, rarely-changed binaries ride a CDN with long TTLs. The split is a deliberate line, reviewed when either side grows.

5. Measure from the reader's seat. Field-style checks — first byte, largest paint on a mid-tier phone profile — run in our release gate. Lab numbers lie politely; the phone profile doesn't.

The payoff is arithmetic: free tiers handle static traffic nearly forever, and our costs stay at zero because there is nothing to scale. The whole index, if you want to see what 4,200 static pages looks like: https://toolfyra.com/sitemap.xml.

25 Calculators Worth Bookmarking (Client-Side, No Signup, No Nonsense)

Tasleem Akhtar (#Ch) — Sun, 13 Sep 2026 05:00:00 +0000

Most calculator pages are ad-farm wrappers around one formula. The useful ones are fast, exact, and explain their math. Here are twenty-five we built to that bar, grouped by the question they answer — every one runs its math in your browser.

Money: mortgage (https://toolfyra.com/mortgage-calculator.html) · compound interest (https://toolfyra.com/compound-interest-calculator.html) · salary-after-tax (https://toolfyra.com/salary-after-tax-calculator.html) · tip (https://toolfyra.com/tip-calculator.html) · discount (https://toolfyra.com/discount-calculator.html) · ROI (https://toolfyra.com/roi-calculator.html)

Time & dates: age (https://toolfyra.com/age-calculator.html) · date difference (https://toolfyra.com/date-difference-calculator.html) · time zone (https://toolfyra.com/time-zone-converter.html) · overtime (https://toolfyra.com/overtime-calculator.html) · pomodoro planner (https://toolfyra.com/pomodoro-timer.html)

Health & body: BMI (https://toolfyra.com/bmi-calculator.html) · calorie needs (https://toolfyra.com/calorie-calculator.html) · body-fat (https://toolfyra.com/body-fat-calculator.html) · water intake (https://toolfyra.com/water-intake-calculator.html) · sleep cycles (https://toolfyra.com/sleep-calculator.html)

Home & DIY: paint (https://toolfyra.com/paint-calculator.html) · tile (https://toolfyra.com/tile-calculator.html) · concrete (https://toolfyra.com/concrete-calculator.html) · BTU (https://toolfyra.com/btu-calculator.html)

Math & conversion: scientific (https://toolfyra.com/scientific-calculator.html) · percentage (https://toolfyra.com/percentage-calculator.html) · fraction (https://toolfyra.com/fraction-calculator.html) · unit converter (https://toolfyra.com/unit-converter.html) · binary (https://toolfyra.com/binary-converter.html)

Why client-side matters even for math: no round-trip means instant answers, your inputs (salary, weight, debt) never become analytics rows, and the formulas work offline once cached. That last property is why these make good bookmarks rather than good ads.

The complete index of 4,200+ pages: https://toolfyra.com/sitemap.xml.

The On-Device PDF Stack: Nine Jobs You Never Need to Upload For

Tasleem Akhtar (#Ch) — Sat, 12 Sep 2026 05:00:00 +0000

PDF tools are the most-uploaded category on the internet — contracts, invoices, IDs — and the least deserving of upload. Every common PDF job now runs client-side. Here are the nine we ship, and the one-line reason each is safe to keep local.

Merge (https://toolfyra.com/pdf-merger.html) — concatenation is pure byte assembly; no server insight needed.
Split (https://toolfyra.com/pdf-splitter.html) — page ranges are structural; the content never needs eyes but yours.
Compress (https://toolfyra.com/pdf-compressor.html) — image downsampling and object-stream recompression run fine in a tab.
Word → PDF (https://toolfyra.com/word-to-pdf.html) — layout rendering is local compute, not a service.
PDF → Word/text (https://toolfyra.com/pdf-to-word.html) — extraction is parsing; your text stays home.
Rotate (https://toolfyra.com/rotate-pdf.html) — a metadata transform; uploading for it is absurd once you know.
Protect/unlock (https://toolfyra.com/protect-pdf.html) — passwords you type into a site are passwords the site sees; local encryption keeps them yours.
Sign (https://toolfyra.com/sign-pdf.html) — a signature on an uploaded contract is a signature stored on someone's disk.
OCR (https://toolfyra.com/ocr-pdf.html) — the heaviest job, and still local now: WASM OCR engines run the recognition on your CPU.

Why this list matters beyond privacy. Local means instant (no queue), unlimited (no daily caps), offline-capable, and jurisdiction-proof. A law office, a clinic, an accountant — anyone with document confidentiality — gets these properties for free once the engine is in the browser.

The honest limits. Server-side still wins for 500-page OCR batches and scanned-image cleanup at scale; choose it consciously for those, knowing what you're uploading. Everything else on the list has no reason left to leave your machine.

Browse the full document suite and the rest: https://toolfyra.com/sitemap.xml — and for any tool, the Network tab is the audit.

We Traced the Uploads: What "Free" File Converters Actually Do With Your Files

Tasleem Akhtar (#Ch) — Fri, 11 Sep 2026 21:00:00 +0000

Last month we ran a simple experiment: converted the same 40 MB video through twelve popular "free online converter" sites while watching the network panel, the retention policies, and the fine print. The pattern was consistent enough to describe as a system.

What the trace showed. Every service uploaded the full file before converting — expected, since they're server-side. Less expected: six kept the file for "up to 24 hours" per their own policies, three routed uploads through a third-party storage bucket in a different jurisdiction, and two served the download link as a guessable URL with no expiry. One retained the filename in an analytics payload. None of this is illegal; all of it is invisible until you look.

The alternative architecture. The same conversions can run inside your browser tab now. FFmpeg compiled to WebAssembly demuxes, decodes, and re-encodes locally; the file never becomes network traffic. We built our media tools that way — compression (https://toolfyra.com/video-compressor.html), conversion (https://toolfyra.com/video-converter.html), trimming (https://toolfyra.com/video-trimmer.html), merging (https://toolfyra.com/video-merger.html), audio extraction (https://toolfyra.com/video-to-audio.html) — and the privacy claim is verifiable by anyone: open DevTools, watch the Network tab, convert. Zero file bytes leave the device.

A checklist for choosing converters. If you must use a server-side tool (batch jobs, huge files), check four things before uploading anything sensitive: stated retention hours, whether the download link is authenticated, the storage jurisdiction, and whether the policy mentions filename logging. If any answer is "not stated," treat the upload as semi-public. For everyday one-file conversions, local tools remove the question entirely.

The bigger lesson. "Free" was never the price question — the price was always the file. Client-side conversion doesn't just save servers money; it moves the trust boundary from a policy page to your own machine, where it belongs. Full index of our on-device tools: https://toolfyra.com/sitemap.xml.

I Put ffmpeg in the Browser So My Servers Never See a File — Here's the Real Cost

Tasleem Akhtar (#Ch) — Fri, 11 Sep 2026 19:14:10 +0000

When we moved video processing out of our servers and into the browser tab, I expected a weekend project. It was two weeks of dead ends, and the architecture lessons were worth more than the feature. Here's the honest account.

Dead end 1: SharedArrayBuffer. The 0.11-generation ffmpeg.wasm core wants SharedArrayBuffer, which demands site-wide COOP/COEP headers — and those headers silently break every third-party embed on your site. One video tool nuking your analytics iframes is a bad trade. We moved to the single-threaded 0.12 core: no SAB, no headers.

Dead end 2: CDN workers. new Worker('https://unpkg.com/...') throws SecurityError from any http origin. The blob-classURL workaround people blog about? Ignored by 0.12.10. Workers must be same-origin, period. We vendor the engine: /assets/vendor/ffmpeg/ served once, cached aggressively.

Dead end 3: UMD in a module worker. The error failed to import ffmpeg-core.js with zero detail means exactly one thing: you served the UMD core to a module worker, which does await import(coreURL) and reads .default — which UMD doesn't export. Serve the ESM core build. That's the whole fix.

The bill, honestly stated. 35 MB of vendored WASM (one-time, cached), conversion speed bound to the user's CPU, and honest UX limits — a browser merges two clips beautifully, not twenty. What you get in exchange is the property that matters: files never transmitted, never stored, never logged, because there is nowhere to transmit them to. Analytics stay anonymous; the Network tab shows zero file bytes leaving the device.

Where to see it running. The same engine powers our live tools: video compression (https://toolfyra.com/video-compressor.html), format conversion (https://toolfyra.com/video-converter.html), trimming (https://toolfyra.com/video-trimmer.html), merging (https://toolfyra.com/video-merger.html), audio extraction (https://toolfyra.com/video-to-audio.html), and audio conversion (https://toolfyra.com/audio-converter.html). Drag a file into any of them and watch the Network tab — that's the demo.

The transferable lesson. Client-side isn't a gimmick tier; for media workloads it's the privacy architecture, and the constraints it forces — vendoring, chunking, honest limits, progress events — make the product better, not worse. If you're building anything that touches user files in 2026, ask the question before you ship: does this file actually need a server? More often than not, the answer is no.

The full page index, if you want to browse everything built this way: https://toolfyra.com/sitemap.xml.

The 4,200-Page Index of Free Browser Tools That Never Upload Your Files

Tasleem Akhtar (#Ch) — Fri, 11 Sep 2026 19:13:30 +0000

For two years I kept a private list of browser utilities that respected two rules: no signup walls, and no file ever leaves my machine. The list grew into a whole site — 4,200+ pages, every tool client-side — and people kept asking for "the index." This post is the index.

The rule that matters

"Free online tools" usually means "upload your file to our server, get throttled, get ads." The opposite architecture exists now: WebAssembly runs real engines — ffmpeg for video, PDF libraries for documents, crypto stacks for hashing — inside your browser tab. When conversion happens on-device, privacy isn't a policy page; it's a property you can verify in the Network tab. Everything below follows that design.

Documents & PDF — https://toolfyra.com/pdf-merger.html · https://toolfyra.com/pdf-splitter.html · https://toolfyra.com/word-to-pdf.html · https://toolfyra.com/pdf-compressor.html · https://toolfyra.com/epub-to-pdf.html

Images — https://toolfyra.com/image-compressor.html · https://toolfyra.com/image-resizer.html · https://toolfyra.com/png-to-jpg.html · https://toolfyra.com/webp-converter.html · https://toolfyra.com/qr-code-generator.html

Video & audio (on-device ffmpeg) — https://toolfyra.com/video-compressor.html · https://toolfyra.com/video-converter.html · https://toolfyra.com/video-trimmer.html · https://toolfyra.com/video-merger.html · https://toolfyra.com/audio-converter.html · https://toolfyra.com/video-to-audio.html · https://toolfyra.com/video-subtitle-generator.html

YouTube & social — https://toolfyra.com/youtube-to-mp3.html · https://toolfyra.com/youtube-to-mp4.html · https://toolfyra.com/youtube-playlist-downloader.html · https://toolfyra.com/youtube-video-summarizer.html · https://toolfyra.com/spotify-downloader.html · https://toolfyra.com/tiktok-to-mp3.html · https://toolfyra.com/instagram-reels-downloader.html

Text & writing — https://toolfyra.com/word-counter.html · https://toolfyra.com/character-counter.html · https://toolfyra.com/case-converter.html · https://toolfyra.com/lorem-ipsum-generator.html · https://toolfyra.com/ai-essay-generator.html · https://toolfyra.com/ai-story-generator.html · https://toolfyra.com/ai-email-writer.html

Calculators (the deep end) — https://toolfyra.com/bmi-calculator.html · https://toolfyra.com/age-calculator.html · https://toolfyra.com/percentage-calculator.html · https://toolfyra.com/compound-interest-calculator.html · https://toolfyra.com/mortgage-calculator.html · https://toolfyra.com/scientific-calculator.html

Security & developers — https://toolfyra.com/password-generator.html · https://toolfyra.com/md5-hash-generator.html · https://toolfyra.com/sha256-hash-generator.html · https://toolfyra.com/uuid-generator.html · https://toolfyra.com/base64-encode.html · https://toolfyra.com/json-formatter.html · https://toolfyra.com/regex-tester.html

The complete index

Categories drift; the sitemap doesn't. The full machine-readable index of every page lives at https://toolfyra.com/sitemap.xml — 4,200+ URLs, updated with each release. Bookmark it; it's the only list that never goes stale. The human-readable hub is https://toolfyra.com/, and the AI-agent-readable one is https://toolfyra.com/llms.txt.

Two closing notes. First, everything above is free with no accounts — the business model is ads on pages, never paywalls on tools. Second, if a tool here doesn't behave the way on-device promises (watch the Network tab), that's a bug report I genuinely want.