Your Domains Are Sitting There Doing Nothing. Here's the $0 Lander Stack That Turns Parked Names into a Lead Engine

If you hold a portfolio of domains — say, 30 names you picked up over the years at $10-12 each — you are currently paying roughly $300-360 a year to let a registrar’s default “this domain is parked” page tell visitors absolutely nothing. That page is the most expensive “coming soon” sign on the internet. The fix costs $0/month and about an hour of work: point every domain at one Cloudflare Worker that serves a custom lander per domain — what the name is, why it’s worth owning, a three-tier price ladder, a lead-capture form wired to durable storage, and per-domain traffic stats. No parking revshare. No 25-30% marketplace commission on the sales you close yourself. And unlike classic ad parking, which pays you cents for type-in clicks, this stack captures the thing that actually converts: an email from someone who wants your exact name. ...

November 10, 2026 · 15 min · 3068 words

Your TLS Handshake Passes and Your JS Is Clean, But Akamai Still Bans You: The HTTP/2 SETTINGS Layer Nobody Forges

Your scraper passes JA4. Your headless Chrome leaks no JavaScript signals. You rotate residential proxies. And Akamai’s Bot Manager still kills the session inside 200 requests. There is a layer between TLS and JavaScript that almost nobody patches: the HTTP/2 SETTINGS frame. Before your client sends a single byte of request data, it announces itself through four values that are dictated by the HTTP/2 library — not by you, not by your proxy, not by your user-agent string. Akamai reads them, hashes them into a compact fingerprint, and scores your session against the known profiles of real browsers. If you are running python-requests, httpx, or even curl, the fingerprint you emit does not match any browser that has ever existed. You are tagged before page load. ...

November 10, 2026 · 10 min · 2109 words

Stop Burning Proxy Credits: A Health-Scoring Pool That Auto-Quarantines Burned IPs Before They Cost You

Your scraper works. Your proxies work. And yet, every month, you’re paying for residential proxy bandwidth that gets burned on 403s from sites that already flagged half your IP pool. You rotate proxies — round-robin, random, sticky sessions — and the blocks still come, because rotation treats every IP as equally good. They are not. Imperva’s 2025 Bad Bot Report puts automated traffic at 51% of all web traffic — the first year bots overtook humans. Anti-bot vendors are priced accordingly: Oxylabs residential proxies run $6/GB at low volume down to $2.50/GB at a terabyte per month; BrightData starts at $5/GB (dropping to $2.50 at scale); Smartproxy (now Decodo) ranges $3.75/GB at 3GB down to $2/GB at 1TB, with pay-as-you-go at $4/GB. Every blocked request through those proxies burns bandwidth credit on a response you can’t use. ...

November 9, 2026 · 14 min · 2858 words

Headless Chrome Is Not a Browser Disguise: Every JS-Layer Bot Signal, Measured, and the Cross-Origin Hole Nobody Patches

Your TLS handshake now passes. The last article in this series fixed that layer — JA4 impersonation gets your scraper a 200 where python-requests got a 403. And yet the target still bans the session within an hour. This article is about the layer above TLS: JavaScript execution signals — everything a page’s script can learn about your browser once it’s running inside it. We drove real Chrome over the raw DevTools Protocol (no Playwright, no stealth plugin, every CDP frame explicit), measured which signals each launch mode leaks, killed the folklore that doesn’t hold in 2026, and found a hole in the most common evasion approach that we have not seen documented anywhere: user-agent overrides don’t reach cross-origin iframes, and the frames quietly report the real headless UA to whoever’s listening. ...

November 9, 2026 · 13 min · 2734 words

Your Webhook Handler Loses Money on Every Deploy: The SQLite Inbox That Makes the Provider's Retry Loop Do Your Queuing

Every payment integration you’ve shipped has the same flaw, and it’s not the code — it’s the window. Your handler receives an event, processes it inline (charge the card, grant the API key, update the ledger), and returns 200. That works until you deploy, the VPS reboots, or the handler throws on an edge case you’ve never seen. Then the event is gone, and with it the money attached to it. The customer paid. Your system never noticed. ...

November 9, 2026 · 13 min · 2565 words

The $6.85 Question: A Cost Engine That Tells You Whether to Buy a Scraping API, Roll Your Own, or Bolt a Captcha Solver Onto a Weak One

Every anti-bot conversation starts with how do I get past it and almost none start with the question that actually decides whether the project lives: what does one thousand successful rows cost, at your real success rate, including the failures you paid for anyway? That’s the only number your client or your boss needs, and it’s the one nobody computes — because the pricing pages are engineered to hide it. Benchmarks exist (we’ll use one), but raw benchmark numbers get misread constantly: the provider with the cheapest sticker price in a 2026 comparison was also the one failing half its requests, which means it was actually the most expensive per row delivered. ...

November 8, 2026 · 10 min · 2091 words

The 97% Model Cascade: Route Every LLM Call to the Cheapest Model That Can Actually Do the Job

Every team shipping an LLM product makes the same decision on day one: pick one model, wire it in, and pay its price on every single call. Usually the model is too strong for most of the workload, because the one that gets picked is the one that survives the hardest task in the demo. That’s how you end up paying flagship prices to classify support tickets that a model costing 25x less per input token handles fine — and at a million calls a month, the difference isn’t a line item, it’s the difference between a profitable product and one you shut down. The fix isn’t “use a smaller model” — that just moves your failure rate. The fix is a cascade: try the cheapest model first, check whether it actually succeeded, escalate only when it didn’t. This article builds the working router, grades its outputs with a second model, and shows you the exact math — including the workload where the cascade loses money. ...

November 8, 2026 · 16 min · 3201 words

The App Works But curl Gets a 401: Reverse-Engineering Mobile API Request Signing With mitmproxy

The endpoint is right there. You can see the request in your proxy: POST /api/v1/orders, a JSON body, three headers you’ve never seen on a web API — X-Client-TS, X-Nonce, X-Signature. You replay it byte-for-byte from a script and get a 403 Forbidden. You change one character of the body and the signature still fails. The mobile app, meanwhile, happily places orders all day. That is request signing, and it is the single most common reason mobile API automation projects stall. Not Captchas, not IP bans — signing. It is also one of the highest-value skills a data-engineering freelancer can sell, because almost no one who can build scrapers can get past it. ...

November 8, 2026 · 11 min · 2172 words

Your Scraper Didn't Crash. It Started Lying: A Drift Sentinel That Catches Silent Breakage (Tested Python + SQLite)

Here’s the failure mode nobody demos: the scraper is green. Cron says it ran. Exit code 0. Logs show requests going out. And the data is wrong — or worse, quietly disappearing. A scraper that crashes is an annoyance; you fix it the morning you notice. A scraper that keeps “working” while its output degrades is a liability, because everything downstream — your pricing engine, your client dashboards, your ML features — keeps consuming the garbage as if it were fine, and the poison spreads through every table it touches before anyone looks. ...

November 8, 2026 · 10 min · 2084 words

The Odd-Lot Loophole in Self-Tender Offers: Buy 99 Shares, Skip the Proration Line, Collect the Full Offer Price (Python Scanner Tested)

When a company buys back its own stock through a self-tender offer, it almost never wants every shareholder’s shares — it wants a fixed dollar amount, and the offer is oversubscribed. The standard resolution is proration: if you tendered 1,000 shares and the company can only take 18% of what was tendered, you get paid for 180 shares and the rest come back. Everyone eats the haircut proportionally. Except one group. Holders of fewer than 100 shares — an “odd lot” — who tender all their shares are pulled out of the proration pool entirely and accepted in full, first, before anyone else gets a dime. This is not a bug. It is a standard clause written into most US issuer self-tender offer documents, rooted in SEC Rule 13e-4, and it exists because companies want the administrative nuisance of sub-100-share holdings off their register. The side effect is a clean, legal, repeatable trade: buy 99 shares below the offer price, tender all of them, collect the full offer price with no proration haircut, repeat on the next offer. ...

November 7, 2026 · 16 min · 3360 words

I Deleted a Live Production Database Mid-Write and Lost 2 Rows: The Durability Runbook Every Automation Product Skips

Here is the post-mortem every small automation product eventually writes and almost nobody publishes: the scraper ran fine for months, then the VPS rebooted mid-write, and three weeks of customer data were gone. Not corrupted in a dramatic way — just quietly absent, because the product was writing with a rollback journal and committing in batches, and the crash window swallowed everything since the last commit. The uncomfortable part is that the fix costs almost nothing. SQLite already ships the machinery for surviving a hard process kill with zero data loss — it’s one PRAGMA — and a project called Litestream streams every commit to object storage for a few dollars a month. We rebuilt the failure in a lab, measured exactly how much data each configuration loses when you pull the power, and turned it into a runbook you can apply to any running product in under an hour. Every number in this article is from a live test on a plain Ubuntu VPS (2 vCPU, SQLite 3.53.1 via Python 3.14) or from the official documentation fetched the day this was written. ...

November 7, 2026 · 10 min · 2035 words

The Crawl Frontier: The Scraping Infrastructure Nobody Talks About (Tested Python + SQLite)

Every scraping tutorial ends the same way: “and now loop over the URLs.” That’s where real projects start dying — not from anti-bot systems, but self-inflicted wounds: the same page fetched forty times, a small shop knocked over by a 500-request burst, a crash losing a four-hour queue. The machinery between “I have a URL” and “I should fetch it now” is called a crawl frontier, and building it properly separates a script from infrastructure. This article builds the real thing: per-domain rate limiting, robots.txt compliance, deduplication, and crash recovery — every line executed and verified before it went in. ...

November 7, 2026 · 11 min · 2265 words