DEV Community: Rahul

I checked 95 well-known sites for broken link previews. 14% had none at all.

Rahul — Sun, 02 Aug 2026 00:26:26 +0000

I checked the link-preview tags on 95 well-known sites. Under half were clean, and
nine sites developers use constantly have no preview tags at all.

If you have ever pasted a link into Slack and got a bare grey URL instead of a title
and image, this is why.

The result

Of 95 sites, 79 responded to an automated check (the rest blocked it). Of those 79:

	count	share
Perfect (100/100)	38	48%
Missing `og:title`	18	23%
Missing `og:image`	15	19%
No preview tags whatsoever	11	14%
`og:image` that returns an error	1	1%

Nine sites with zero preview tags

Each of these was re-checked by hand with a real Chrome user-agent to rule out
bot-blocking. All returned HTTP 200 with no og:* and no twitter:* tags:

news.ycombinator.com
python.org
swift.org
ruby-lang.org
arxiv.org
jstor.org
arstechnica.com
trello.com
replicate.com

Hacker News having no link preview is almost a design statement. python.org,
swift.org and ruby-lang.org are harder to explain — those are the front doors of
three major languages, and every share of them renders as a naked URL.

The subtler failure

Missing tags are at least honest. The nastier case is tags that look fine but point
at an image that no longer loads — you keep sharing links believing the preview works,
because you never see what other people see. One site in the sample had exactly this.

Worth knowing: og:image needs an absolute URL. A relative path silently produces
no image on most platforms, and nothing in your own browser will ever warn you.

Method, and where it is weak

95 sites chosen for recognisability across dev tools, languages, SaaS, news, reference and community — not a ranked top-N list.
Homepages only. Deeper pages often have tags the homepage lacks, so this measures the front door, not the whole site.
16 sites blocked the automated request. Blocked is reported as unknown, not as a score of zero — conflating "we could not check" with "this is broken" is the easiest way to produce a wrong number, and I hit that bug while building this.
Two sites were dropped from the final list: one was rate-limited, and reddit.com returned 403 and 200 on different attempts, so its result was not stable enough to publish.

Check your own

I wrote the checker as an open-source tool. It validates Open Graph and Twitter Card
tags, confirms the preview image actually loads, and also checks robots.txt and
sitemap.xml. Free, no signup:

Live: https://ogcheck.onrender.com
Source (MIT): https://github.com/rahulatrkm/ogcheck

There is also a GitHub Action, so a build can fail when a page ships without a valid
preview — which is the only way I know to stop this regressing quietly.

If you run it on your own site and get a surprising result, I would genuinely like to
hear it — especially any false positives, since that is the part I most want to fix.

I built a tool that explains any confusing document in plain words (your level, your language)

Rahul — Sat, 01 Aug 2026 10:31:21 +0000

Everyone keeps running into documents that gatekeep their own life

A blood test full of abbreviations. A legal letter. A bank statement. A
government form. A dense insurance policy. To understand your own information
you often need a professional — which costs time and money.

So I built Plainly: paste any confusing text and get it back in plain
language — at the reading level you choose (from "like I'm 10" to "keep it
precise") and in your language.

You get a TL;DR, key points, things to watch out for (deadlines, anything that
needs action), the hard words decoded, and practical next steps.

Example

Paste a cryptic blood report like Hb 9.2 g/dL, MCV 72 fL, ferritin 8 ng/mL and
it comes back with: "Your blood test shows anemia — low red blood cells — most
likely caused by not having enough iron," plus what each term means and what to
do next.

It also checks if something is real

There's a second mode — RealCheck — where you paste a suspicious message or a
claim and it reasons calmly about whether it's plausible, calling out scam and
misinformation red flags (urgency, pay-a-fee, prize-you-didn't-enter, crypto
doubling, verify-your-account links) and how to check it yourself.

Honest about what it is

It's an AI explainer/reasoner, not a doctor, lawyer or fact-checking oracle —
great for understanding and for asking better questions, not a final authority.
Nothing is stored, no signup, free.

Try it: https://plainly-n6ni.onrender.com
Open source (MIT): https://github.com/rahulatrkm/plainly

Under the hood it's a tiny Python (stdlib) backend forwarding to a free LLM, with
a strict "JSON only" contract + retries to keep responses reliable. What kind of
confusing document should I make it handle better?

I built a tool that reads your contract and flags the risky clauses in plain English

Rahul — Fri, 31 Jul 2026 09:30:57 +0000

The contract clause that almost cost my friend their side projects

A friend nearly signed a freelance contract that assigned the company all the
IP they created — including personal side projects done on their own time — plus
a 3-year industry-wide non-compete and net-90 payment terms. To them it just
looked like normal legal boilerplate. It wasn't.

Most of us sign leases, freelance agreements, NDAs and job offers we don't fully
understand, because a lawyer costs hundreds and the language is deliberately
dense. So I built a small tool to make contracts legible for non-lawyers.

What it does

Paste a contract (or the clauses you're unsure about) into
ClauseClear and it returns:

a plain-English summary and a risk score
the clauses that actually matter — each with what it means, why it matters, and what to ask for instead
protections that seem to be missing
questions to ask before you sign

It's honest that it's an AI first-read, not legal advice — but as a "should I
worry about this?" gut-check before you sign, it's genuinely useful.

How it's built

A tiny Python (WSGI, standard-library) backend forwards your text to a free, OpenAI-compatible LLM and asks for a structured review
The frontend is a single static page — risk gauge, severity-colored clause cards, copy-to-clipboard report
Nothing is stored. No signup. Free to use.
Open source (MIT): https://github.com/rahulatrkm/clauseclear

Getting the model to reliably return clean JSON (instead of chatty preamble or
truncated output) was the fiddly part — solved with a strict "output only JSON"
contract, reasoning-strip, truncated-JSON repair, and retries.

Try it

Paste something gnarly — an old lease, a gig contract, a ToS — and see what it
flags: https://clauseclear-app.azurewebsites.net

I'd love feedback on the review quality: what did it miss, and is the "suggested
pushback" actually useful or too generic?

Generate invoice PDFs without a headless browser

Rahul — Mon, 27 Jul 2026 17:13:48 +0000

You probably don't need Chromium to make a PDF

The default advice for "generate a PDF" is HTML-to-PDF via headless Chromium
(Puppeteer/Playwright). For arbitrary web pages, fine. For a document with a
known layout — an invoice, a receipt, a statement — it's the wrong tool:

~300MB of Chromium to ship and keep patched
system libraries that break on minimal/serverless images
seconds of cold-start on the first request
--no-sandbox foot-guns and memory tuning

For structured documents you need correct layout and correct math, not a
browser.

The lighter approach: render straight from data

InvoicePDF takes JSON and returns a PDF — no browser involved:

curl -X POST https://invoicepdf-app.azurewebsites.net/invoice \
  -H "Content-Type: application/json" \
  -d '{"number":"INV-1","currency":"USD","seller_name":"Me LLC",
       "buyer_name":"Acme Corp",
       "items":[{"description":"Consulting","quantity":8,"unit_price":120}],
       "tax_rate_percent":10}' \
  --output invoice.pdf

Under the hood it's fpdf2 — pure Python, no system deps — so it starts
instantly, sips memory, and hosts on a free tier like a static app.

Bonus: get the money math right

Never use floats for money (0.1 + 0.2 != 0.3). Keep amounts as integer minor
units (cents) and format at the very end, so $27.00 + 10% tax is exactly
$29.70. InvoicePDF does this internally.

Try it

Live playground: https://invoicepdf-app.azurewebsites.net
Sample PDF: https://invoicepdf-app.azurewebsites.net/sample
Open source (MIT): https://github.com/rahulatrkm/invoicepdf

If you've been reaching for headless Chromium to make invoices, this is a much
lighter path. Feedback welcome.

Is your sitemap.xml quietly broken? A 1-line way to check

Rahul — Mon, 27 Jul 2026 16:11:32 +0000

The sitemap you set up once and never checked again

A sitemap.xml helps search engines discover and crawl your pages efficiently.
But a single stray character makes the whole file invalid XML — and crawlers just
silently skip it. Or it points at an old path after a migration. Or it's empty.
Nothing tells you. You just get crawled less thoroughly.

I added a free sitemap check to OGCheck (alongside its Open Graph
and robots.txt checks).

Check it in one request

curl "https://ogcheck-app.azurewebsites.net/sitemap?url=https://your-site.com"

It confirms your sitemap is reachable (not a 404/500), is valid XML, and
actually lists URLs rather than being empty — and tells you how many.

The sitemap problems that quietly cost you crawl budget

Invalid XML — one unescaped & or stray tag breaks the whole file for crawlers.
Empty sitemap — generated once, never repopulated after a CMS change.
Unreachable — a 404 or 500 after a migration or a misconfigured route.
Not referenced in robots.txt — search engines have to guess it's there.

While you're at it

The same free API also checks your robots.txt (/robots?url=…) and your social
preview / og:image (/check?url=…). It's zero-dependency (pure Python stdlib),
open source: https://github.com/rahulatrkm/ogcheck.

What else silently breaks your site's visibility that a one-request check could
catch? Genuinely curious — feedback welcome.

How to generate an invoice PDF in Python (2 clean ways)

Rahul — Mon, 27 Jul 2026 16:11:18 +0000

How to generate an invoice PDF (without the usual pain)

If you've tried to generate an invoice or receipt PDF programmatically, you know
the options are all annoying: low-level PDF drawing, HTML-to-PDF via headless
Chromium (heavy, slow, breaks on fonts), or a bloated reporting library. For a
document, that's overkill.

Here are two clean ways — a few lines of Python, or a single API call.

Option A — one API call (no dependencies)

InvoicePDF takes JSON and returns a PDF. From any language:

curl -X POST https://invoicepdf-app.azurewebsites.net/invoice \
  -H "Content-Type: application/json" \
  -d '{"number":"INV-1","currency":"USD","seller_name":"Me LLC",
       "buyer_name":"Acme Corp",
       "items":[{"description":"Consulting","quantity":8,"unit_price":120}],
       "tax_rate_percent":10}' \
  --output invoice.pdf

That's it — application/pdf comes back. Free tier, no signup to try. There's a
live playground at https://invoicepdf-app.azurewebsites.net where you can edit the JSON and see the PDF.

Option B — pure Python with fpdf2

If you'd rather keep it in-process, fpdf2 is pure Python (no system libs):

from fpdf import FPDF

pdf = FPDF()
pdf.add_page()
pdf.set_font("Helvetica", "B", 20)
pdf.cell(0, 12, "INVOICE", ln=True)
pdf.set_font("Helvetica", size=11)
pdf.cell(0, 8, "Consulting  8 x $120.00 = $960.00", ln=True)
pdf.output("invoice.pdf")

The one thing people get wrong: money math

Do not use floats for money. 0.1 + 0.2 != 0.3 in floating point, and on an
invoice that becomes $29.700000001. Store amounts as integer minor units
(cents), do the math in integers, and format at the end. InvoicePDF does this
internally so totals are always exact.

Try it

Live: https://invoicepdf-app.azurewebsites.net · Sample: https://invoicepdf-app.azurewebsites.net/sample
Open source (MIT): https://github.com/rahulatrkm/invoicepdf

What would make it genuinely useful in your stack — logos, templates, webhooks?
Feedback welcome.

I made an invoice PDF API that doesn't need a headless browser

Rahul — Mon, 27 Jul 2026 06:17:32 +0000

Generating a PDF shouldn't require a headless browser

Every time I needed to generate an invoice or receipt PDF, the options were:
wrestle a low-level PDF library, fight a templating engine, or spin up headless
Chromium (slow, heavy, breaks on fonts, painful to host). For a document, that
felt absurd.

So I built InvoicePDF: POST JSON, get a clean invoice PDF back.
That's the whole thing.

curl -X POST https://invoicepdf-app.azurewebsites.net/invoice \
  -H "Content-Type: application/json" \
  -d '{
    "number": "INV-2026-001",
    "currency": "USD",
    "seller_name": "Your Company LLC",
    "buyer_name": "Acme Corp",
    "items": [
      { "description": "Consulting (hours)", "quantity": 8, "unit_price": 120 },
      { "description": "Software license", "quantity": 1, "unit_price": 299 }
    ],
    "tax_rate_percent": 10,
    "notes": "Thank you!"
  }' --output invoice.pdf

Why pure Python (no chromium)

It's built on fpdf2 — a pure-Python PDF library — so there's no headless
browser and no system dependencies. That means it starts instantly, uses
almost no memory, and deploys on a free tier like a static app. For structured
documents (invoices, receipts, statements), you don't need a browser; you need
correct layout and correct math.

The money math is exact

Financial documents can't have floating-point drift. InvoicePDF does all money
as integer minor units (cents/paise) internally, so $27.00 subtotal + 10% tax is exactly $29.70 — never $29.700000001. It handles multiple currencies
(including zero-decimal ones like JPY), fractional quantities (e.g. hours), tax,
notes, and due dates.

Try it / use it

Live playground (edit JSON, get a PDF): https://invoicepdf-app.azurewebsites.net
Sample PDF: https://invoicepdf-app.azurewebsites.net/sample
Open source (MIT): https://github.com/rahulatrkm/invoicepdf

Free tier is 100 invoices/mo, no signup. If you generate a lot, there's a cheap
paid tier.

What would make this actually useful in your stack — logo/branding, a hosted
template editor, webhooks? Genuinely curious — feedback welcome.

The robots.txt mistake that hides your whole site from Google

Rahul — Mon, 27 Jul 2026 05:11:05 +0000

One line can hide your whole site from Google

Disallow: / in your robots.txt tells every crawler to ignore your entire
site. It's shockingly common — usually left over from a staging config that got
copied to production. And nothing tells you: your pages just quietly stop
ranking.

I kept getting bitten by robots.txt and sitemap.xml issues, so I added free
checks for them to OGCheck.

Check your robots.txt in one request

curl "https://ogcheck-app.azurewebsites.net/robots?url=https://your-site.com"

It confirms the file is reachable, parseable, flags a site-wide block,
and tells you whether it points at your sitemap.

The robots.txt mistakes that quietly cost you traffic

Disallow: / — blocks everything. The classic staging-to-prod accident.
Missing file — crawlers assume everything is allowed, which may expose pages you didn't mean to (and you lose the chance to point at your sitemap).
No Sitemap: line — search engines crawl your site less efficiently.
Blocking your CSS/JS — Google renders pages; blocking assets can hurt how it sees them.

While you're at it, check your sitemap too

A broken or empty sitemap.xml hurts crawl efficiency the same quiet way:

curl "https://ogcheck-app.azurewebsites.net/sitemap?url=https://your-site.com"

Both checks are free, zero-dependency (pure Python stdlib), and open source:
https://github.com/rahulatrkm/ogcheck. There's also a social-preview check
(/check?url=…) that confirms your og:image actually loads.

Feedback welcome — what else silently breaks your site's visibility that a
one-request check could catch?

Your blog's link preview is probably broken — here's a 1-line CI check

Rahul — Mon, 27 Jul 2026 04:54:24 +0000

The silent bug that quietly kills your click-through

You add <meta property="og:image" content="...">, the preview looks fine when
you test it, you ship. Weeks later the image gets moved, the CDN path changes, or
it was a relative URL all along — and now every share is a blank card. Your
click-through quietly drops and nothing alerts you.

Catch it in one request (or in CI)

I built OGCheck to catch exactly this. It parses your Open Graph +
Twitter Card tags, scores them, and — the key part most validators skip —
actually requests the og:image to confirm it returns HTTP 200.

python -m ogcheck https://your-site.com/blog/post
# exits non-zero if og:image 404s or required tags are missing -> perfect for CI

There's a JSON API and a GitHub Action too:

- uses: rahulatrkm/ogcheck@v1
  with:
    url: https://your-site.com

The 5 things that actually break previews

The image URL 404s (most common)
A relative URL instead of an absolute one
A cached old preview on the platform (re-scrape to bust it)
Wrong dimensions or file type (use PNG/JPG at 1200×630)
Crawlers blocked by robots.txt or auth

It's a small "site health" suite now

Same free API also checks the other things that silently break how your site
shows up:

GET /check?url=… — social preview (Open Graph + og:image loads)
GET /robots?url=… — robots.txt (catches an accidental site-wide Disallow: /)
GET /sitemap?url=… — sitemap.xml (valid XML, reachable, lists URLs)

It's free, zero-dependency (pure Python stdlib), and open source:
https://github.com/rahulatrkm/ogcheck

If you monitor a lot of pages, I'm thinking about a paid "watch these URLs and
alert me when a preview breaks" tier — would that be useful? Honest feedback
very welcome, especially on false positives.