HASHNODE SEO AUDIT · DEVELOPER BLOG · CUSTOM DOMAIN · ARTICLE JSON-LD
Free Hashnode SEO Audit
Hashnode is a developer blogging platform with built-in SEO features: auto-generated Article JSON-LD, custom domain canonical configuration, built-in sitemap, and OG image generation. DeepSEOAnalysis validates the rendered HTML output — checking that Hashnode\'s Article JSON-LD is correctly formatted for Google\'s Rich Results, custom domain canonicals are accurate, cover images meet publisher logo and image requirements, real CrUX Core Web Vitals, and all five AI visibility signals for technical content frequently cited by AI systems — free with no signup.
WHAT WE CHECK
6 Hashnode-specific SEO checks
Hashnode SEO auditing covers custom domain canonical accuracy and SEO tab field usage, publication URL structure and slug quality, auto-generated Article JSON-LD validation with property-level errors (headline length, image URL, publisher logo), sitemap completeness and robots.txt AI crawler configuration, real CrUX Core Web Vitals with Hashnode CDN and third-party embed impact, and AI visibility for developer technical content frequently cited by AI systems.
Hashnode custom domain and canonical configuration
Hashnode publications can be accessed at both the default hashnode.dev subdomain and a custom domain. The canonical configuration determines which URL Google indexes. The audit checks: custom domain canonical accuracy (each post\'s canonical tag must point to the custom domain URL — if a post is accessible at both `username.hashnode.dev/post-slug` and `blog.yourdomain.com/post-slug`, the canonical must declare the custom domain as the preferred URL; Hashnode handles this automatically when a custom domain is configured, but the audit verifies the rendered canonical tag points to the correct domain); meta title and description from SEO tab (Hashnode\'s post editor SEO tab allows separate SEO title and SEO description fields — if these are empty, Hashnode falls back to the post title and subtitle, which are often not optimised for search intent; all posts with empty SEO fields relying on automatic fallbacks are flagged); OG meta tags (og:title, og:description, og:image from the post\'s SEO settings and cover image — the audit validates all four OG property types are present and correctly formatted); cross-post canonical accuracy (posts with manually set canonical URLs pointing to an external publication must use the full absolute URL of the original — relative URLs or incorrect canonical targets create duplicate content risk); and noindex status (Hashnode allows toggling a post as "Hidden" which sets noindex — the audit checks for published-but-hidden posts that appear in the sitemap with a noindex tag, which is a conflicting signal).
Hashnode publication URL structure and routing
Hashnode generates URLs from the post slug, which can be set manually in the post editor. The audit checks: slug quality (Hashnode auto-generates slugs from the post title, including stop words and special characters that can create long, unclean URLs — the audit flags slugs that are over-long (>70 characters) or contain unusual character patterns; slugs can be customised in the post editor before publication but cannot be changed after publication without creating a broken link on existing shares); subdomain vs subdirectory positioning (custom domain publications use a subdomain by default — `blog.domain.com` — with all blog URL authority accumulating on the subdomain, not the main domain; the audit notes this architecture with context on the subdomain/subdirectory debate for developer blogs); internal links between blog posts (internal links within the Hashnode publication use relative or absolute URLs pointing to the custom domain — the audit checks for broken internal links and links still using the hashnode.dev origin instead of the custom domain after migration); series and tag URLs (Hashnode generates tag pages and series pages — `blog.domain.com/tag/typescript` — these are crawlable and consume crawl budget; the audit checks whether these pages have canonical tags and whether they appear in the sitemap); and redirect handling (Hashnode doesn\'t support custom redirects in the free tier — if a post slug is wrong and needs changing after publication, the only option is deleting and republishing, which loses engagement; this is flagged as a limitation to account for in publishing workflow).
Article JSON-LD and structured data validation
Hashnode auto-generates Article JSON-LD for every post. The audit validates the output against Google\'s Rich Results requirements. Required Article properties checked: `headline` (from post title — must be under 110 characters; Hashnode does not enforce a character limit on post titles in the editor, so long titles produce oversized headlines that fail Google\'s Rich Results validation; flagged with exact character count); `image` (from post cover image — must be an absolute URL; if no cover image is set, Hashnode\'s fallback OG image generator produces an auto-generated image using the publication name; the audit checks whether the image URL is absolute and accessible); `datePublished` (from the post publication timestamp — the audit verifies this is in a valid ISO 8601 format); `dateModified` (from the last edit timestamp — the audit checks this is present and correct; Hashnode updates dateModified on every save, including minor edits, which correctly keeps dateModified current); `author` as `Person` with `name` property (from the Hashnode profile name — the audit checks the `Person.name` is present and non-empty); `publisher` as `Organization` with `name` and `logo` (from the publication name and publication avatar — the audit checks the `logo.url` is an absolute URL, accessible, and meets Google\'s requirements for publisher logos: at most 600×60px). Common Hashnode JSON-LD issues: missing `image` when no cover photo is set; `headline` too long when post titles exceed 110 characters; missing `publisher.logo` on publications without a configured avatar. FAQPage JSON-LD is not auto-generated by Hashnode — flagged as a GEO opportunity for developer blog content with FAQ-structured sections.
Hashnode sitemap and GraphQL API crawl configuration
Hashnode auto-generates a sitemap at `[publication-url]/sitemap.xml`. The audit checks: sitemap accessibility (the sitemap must be accessible at the custom domain — if the sitemap is only accessible at the hashnode.dev subdomain after custom domain configuration, it should be verified in GSC against the correct property); sitemap completeness (Hashnode\'s sitemap includes all published, non-hidden posts; the audit crawls all sitemap URLs and checks they return 200 — 404s indicate posts that were deleted or slugs that changed); lastmod accuracy (Hashnode includes the `<lastmod>` date in the sitemap from the post\'s last modification date — the audit verifies lastmod is present and recent for recently edited posts); robots.txt configuration (the audit checks `robots.txt` at the publication root — Hashnode generates a basic robots.txt; the audit verifies it\'s not blocking Googlebot, key post URLs, or the sitemap itself; and critically checks for AI crawler user agents — Hashnode\'s generated robots.txt typically allows all crawlers by default, but this can change with Hashnode platform updates); and Hashnode GraphQL API exposure (Hashnode\'s public GraphQL API at `gql.hashnode.com` allows querying publication post data — this is not an SEO issue but the audit notes the API availability for developers who want programmatic access to post data for building supplementary tools like automated llms.txt generation from the publication\'s posts).
Core Web Vitals for Hashnode publications
Hashnode is a hosted platform — Core Web Vitals are largely determined by Hashnode\'s infrastructure and theme, not by the publisher. The audit uses real CrUX field data for the actual user experience. **LCP** — the primary LCP candidate on Hashnode posts is typically the post cover image. Hashnode serves images from its CDN with automatic format optimisation (WebP delivery to supporting browsers). The cover image is loaded with high priority in Hashnode\'s HTML output. LCP issues on Hashnode posts are typically caused by: large cover images that haven\'t been resized before upload (Hashnode\'s CDN serves the uploaded size, not auto-resizing to display size unless the image upload is handled through Hashnode\'s image uploader); code blocks with syntax highlighting that require large JavaScript bundles; or Hashnode\'s own CDN latency for requests from specific geographic regions. **INP** — Hashnode\'s default theme has limited client-side JavaScript (primarily comment system, reaction buttons, and newsletter subscription form); INP is typically good. Third-party embeds (CodeSandbox, StackBlitz, custom Twitter/GitHub embeds) injected via Hashnode\'s embed feature can introduce main-thread-blocking JavaScript that worsens INP. **CLS** — Hashnode\'s image rendering typically includes explicit dimensions, reducing CLS. The main CLS risk on Hashnode is the newsletter subscription banner that appears after scroll — if it\'s injected above the viewport, it causes layout shift. **TTFB** — Hashnode serves publications from its CDN edge; TTFB is generally low (under 500ms for most regions). The CrUX field data shows real-world performance including geographic distribution of the publication\'s readers.
AI visibility for Hashnode developer blogs
Developer blogs on Hashnode are frequently cited by AI systems — technical how-to content, tutorial posts, and problem-solution articles are high-value AI Overview and AI assistant citation targets. The audit checks all five AI visibility signals. For `robots.txt` AI crawler access: Hashnode\'s platform-generated robots.txt typically uses `User-agent: *` with no Disallow, allowing all crawlers including GPTBot, ClaudeBot, and PerplexityBot. The audit verifies this is still the case (Hashnode platform updates can change the generated robots.txt template). For `llms.txt`: Hashnode does not natively generate llms.txt. Developer bloggers using Hashnode who want llms.txt coverage can: (1) use Hashnode\'s Custom Pages feature (Pro) to create a `/llms.txt` page with links to key posts; (2) maintain a separate llms.txt on their main domain that references the blog subdomain content; or (3) use Hashnode\'s GraphQL API to programmatically generate and host llms.txt externally. The audit checks for llms.txt at the publication root and notes the absence. For `FAQPage` JSON-LD: Hashnode does not auto-generate FAQPage JSON-LD; posts with FAQ-structured content (questions as headings, answers as paragraphs) could benefit from this. The audit checks for FAQPage JSON-LD and flags posts with question-format H2/H3 headings as FAQPage candidates. For question-heading ratio and content chunkability: Hashnode Markdown posts often use question-format headings naturally (technical posts frequently use "How do I...?", "Why does...?", "What is...?" as section headings) — the audit measures the question-heading ratio and average section length in the rendered HTML.
HOW IT WORKS
Audit your Hashnode blog in 60 seconds
- Enter your Hashnode publication URL. Use your custom domain URL (e.g., `blog.yourdomain.com`) or your hashnode.dev publication URL. No Hashnode account credentials, API keys, or admin access needed. Works for any Hashnode publication — free, Pro, or Team plans. Audit a specific post URL for post-level checks or the publication root for site-wide checks.
- We crawl and analyse. The engine validates Hashnode's auto-generated Article JSON-LD (headline length, image URL absoluteness, datePublished/dateModified format, author Person object, publisher Organization with logo) against Google's Rich Results specs with property-level error messages; checks custom domain canonical accuracy; verifies sitemap completeness and robots.txt AI crawler configuration; measures CrUX Core Web Vitals from real Chrome user data; and evaluates all five AI visibility signals in the rendered HTML — including FAQPage JSON-LD absence on posts with question-format headings.
- You get a prioritised report. Hashnode-specific issues first — post titles over 110 characters producing oversized JSON-LD headlines, missing cover images causing absent Article JSON-LD image properties, cross-post canonicals pointing to hashnode.dev instead of the intended original source, AI crawler gaps in robots.txt, FAQPage JSON-LD opportunities on technical posts with question headings — then general SEO findings, each with platform-specific context for fixing within Hashnode's editor or publication settings.
FAQ
Questions about the Hashnode SEO audit
Does Hashnode have built-in SEO features?
Hashnode (hashnode.com) is a developer blogging platform with built-in SEO features that cover the most common blog SEO needs. Key Hashnode SEO capabilities: (1) **Custom domain support** — Hashnode publications can use a custom domain (yourdomain.com) instead of the default username.hashnode.dev subdomain. Custom domain publications benefit from domain authority building on your own domain rather than a shared subdomain. The canonical tag on custom domain posts points to the custom domain URL. (2) **Custom title and meta description per post** — Hashnode\'s post editor includes an "SEO" tab with separate fields for SEO title (overrides the post title for the meta title) and SEO description (the meta description). These are independent of the post\'s display title and subtitle. (3) **Canonical URL control** — for cross-posting content originally published elsewhere, Hashnode allows setting a custom canonical URL pointing to the original source. This prevents duplicate content issues from syndicated posts. (4) **OG image** — Hashnode auto-generates an Open Graph image for each post using the post title and publication avatar. Custom OG image upload is supported per post. (5) **Built-in sitemap** — Hashnode generates a sitemap at `[publication-url]/sitemap.xml` listing all published posts with their URLs and publication dates. (6) **Auto-generated Article JSON-LD** — Hashnode automatically outputs `Article` schema.org JSON-LD in the `head` of each post page: headline, datePublished, dateModified, author (with name), description, and image. (7) **RSS feed** — Hashnode generates an RSS feed at `[publication-url]/rss.xml` for feed-based content discovery. (8) **robots.txt** — Hashnode generates a robots.txt file at the publication root. Custom domain publications can be configured to allow or disallow specific paths.
How does Hashnode handle SEO for custom domains?
Custom domain setup in Hashnode (publication settings → Domain → Add Custom Domain) maps the Hashnode publication to your own domain via DNS CNAME records. When a custom domain is configured: (1) all canonical tags on post pages point to the custom domain URL (e.g., `https://blog.yourdomain.com/post-slug`), not the default hashnode.dev subdomain; (2) the Hashnode CDN serves the publication under your custom domain, with automatic HTTPS via Let\'s Encrypt; (3) the sitemap is accessible at your custom domain (`https://blog.yourdomain.com/sitemap.xml`); (4) Google Search Console should be verified for the custom domain property, not for hashnode.dev. Important SEO consideration for the subdomain vs subdirectory debate: Hashnode publishes to a subdomain (`blog.yourdomain.com`) by default, not a subdirectory (`yourdomain.com/blog`). Google treats subdomains as separate entities for most practical purposes — internal links from the blog subdomain to the main domain are treated more like external links than same-domain internal links, and blog content authority doesn\'t consolidate as directly into the main domain as a subdirectory would. If maximising domain authority consolidation is a priority, a subdirectory blog (yourdomain.com/blog) powered by a self-hosted Next.js or WordPress setup accumulates authority in the main domain more effectively than a Hashnode subdomain publication. For developer-focused blogging where the primary goal is developer community visibility rather than main domain authority consolidation, Hashnode\'s custom subdomain setup is a pragmatic choice.
Does Hashnode generate structured data for blog posts?
Yes. Hashnode automatically generates `Article` JSON-LD structured data in the `head` of every published post. The auto-generated JSON-LD includes: `@type: "Article"`, `headline` from the post title, `description` from the post subtitle or SEO description, `datePublished` from the post publication date, `dateModified` from the last edit date, `author` as a `Person` object with the author\'s Hashnode name, `image` from the post cover image or auto-generated OG image, and `publisher` as an `Organization` object with the publication name and logo. Hashnode does not natively generate `FAQPage` JSON-LD — FAQ content in a Hashnode post is rendered as regular Markdown content without structured data markup. For developer bloggers wanting FAQPage JSON-LD on Hashnode posts: there is no built-in method; options include using Hashnode\'s Custom CSS/JavaScript injection (Pro feature) to inject FAQ JSON-LD for specific posts, or cross-posting to a self-hosted blog with full structured data control and setting the Hashnode post canonical to point to the original. The Article JSON-LD Hashnode generates is generally valid for Google\'s Rich Results — the audit validates that all required properties are present and correctly formatted, as Hashnode\'s implementation occasionally has issues with the image property (using a relative URL or missing the image entirely when no cover image is set).
Is the Hashnode SEO audit free?
Yes. The complete audit is free with no signup and no email gate. Enter the URL of your Hashnode publication or any specific post — the audit crawls the rendered HTML as Googlebot would, checking Hashnode\'s auto-generated Article JSON-LD, canonical configuration, custom domain setup, sitemap accessibility, and real CrUX Core Web Vitals. Works for any Hashnode publication whether using a custom domain or the default hashnode.dev subdomain. Paid DeepSEOAnalysis plans add saved report history, scheduled monitoring for multiple blog posts, larger crawls, and white-label agency reporting.