SEO Basics That Developers Keep Getting Wrong
By The IT Hustle Team
This article was generated with AI assistance and reviewed by our team for accuracy and quality. All technical information and examples have been verified.
Developers build incredible applications. Then they wonder why nobody can find them on Google. The code is clean, the UI is polished, the performance is solid — but the site is invisible to search engines.
SEO isn't marketing magic. It's a set of technical requirements that developers are uniquely qualified to implement — yet consistently get wrong. Most SEO mistakes I see aren't from marketers. They're from developers who treat SEO as someone else's problem.
Here's the thing: Google's crawler is just another user of your application. If your app doesn't work for that user, you're losing traffic you already earned.
Meta Tags That Actually Matter
Developers either ignore meta tags entirely or stuff every possible tag into the <head>. Both are wrong. Here are the ones that actually affect rankings and click-through rates:
Title Tag: The Most Important Element
The <title> tag is the single most impactful on-page SEO element. Google uses it to understand what your page is about, and it's what users see in search results. Get it wrong and everything else barely matters.
<title>Home</title>
<title>My App</title>
<title>Dashboard - App - Company - Welcome</title>
Properly optimized:
<title>Free JSON Formatter & Validator | The IT Hustle</title>
<title>Resume Review Tool - Get ATS Feedback in 30 Seconds</title>
Title tag rules:
- 50-60 characters max (Google truncates longer titles)
- Primary keyword near the beginning
- Every page gets a unique title — never duplicate
- Brand name at the end, separated by | or -
- Write for humans who are scanning search results, not for bots
Meta Description: Your Ad Copy
Meta descriptions don't directly affect rankings, but they affect click-through rate — which indirectly affects rankings. Think of them as free ad copy on Google's search results page.
<meta name="description"
content="Free online JSON formatter with syntax highlighting,
validation, and minification. No login required. Paste your
JSON and get instant results." />
- 150-160 characters max
- Include a call to action ("Try free," "No login required")
- Unique per page — if you don't set one, Google auto-generates one from your content (often poorly)
Open Graph and Twitter Cards
These don't affect Google rankings, but they affect how your links look when shared on social media, Slack, Discord, and messaging apps. Developers forget these constantly, so their links show up as a boring plain URL.
<meta property="og:title" content="Free JSON Formatter" />
<meta property="og:description" content="Format, validate, and minify JSON instantly." />
<meta property="og:image" content="https://example.com/og-json-tool.png" />
<meta property="og:url" content="https://example.com/tools/json-formatter" />
<meta name="twitter:card" content="summary_large_image" />
Generate all of these tags instantly with our Meta Tag Generator — just fill in your page details and copy the HTML.
Canonical URLs: The Duplicate Content Fix
This is the SEO concept developers most often get wrong. If your page is accessible at multiple URLs, Google doesn't know which one to rank:
https://example.com/tools/json
https://example.com/tools/json/
https://example.com/tools/json?ref=nav
https://www.example.com/tools/json
http://example.com/tools/json
Google sees these as five different pages with identical content. Your ranking signal gets split five ways. The fix is a canonical tag:
<link rel="canonical" href="https://example.com/tools/json" />
Every page should have a canonical URL. Pick one URL format (with or without trailing slash, www or non-www) and make it canonical everywhere. Redirect the alternatives.
Structured Data: Speaking Google's Language
Structured data (Schema.org markup) tells Google exactly what your content is — an article, a product, a tool, a FAQ. Without it, Google guesses. With it, you can get rich results (star ratings, FAQ accordions, how-to steps) that take up more space in search results.
<script type="application/ld+json">
{
"@context": "https://schema.org",
"@type": "WebApplication",
"name": "JSON Formatter",
"description": "Free online JSON formatting tool",
"url": "https://example.com/tools/json",
"applicationCategory": "DeveloperApplication",
"offers": {
"@type": "Offer",
"price": "0",
"priceCurrency": "USD"
}
}
</script>
Most useful structured data types for developers:
- Article — blog posts, guides (enables rich snippets with date and author)
- FAQPage — FAQ sections (can show Q&A directly in search results)
- WebApplication — tools, SaaS products
- HowTo — tutorials, step-by-step guides
- BreadcrumbList — site navigation (shows breadcrumbs in search results)
Sitemap.xml and Robots.txt
These two files are your communication channel with search engine crawlers. Developers either forget them entirely or misconfigure them in ways that tank their SEO.
sitemap.xml
A sitemap tells Google every page you want indexed. Without one, Google relies on following links — which means orphan pages (pages with no internal links) never get discovered.
<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
<url>
<loc>https://example.com/tools/json-formatter</loc>
<lastmod>2026-03-15</lastmod>
<changefreq>monthly</changefreq>
<priority>0.8</priority>
</url>
</urlset>
Common mistakes: including URLs that return 404, including non-canonical URLs, not updating lastmod dates, or including pages blocked by robots.txt.
robots.txt
Robots.txt tells crawlers which parts of your site to skip. The most common developer mistake is deploying a staging robots.txt to production:
User-agent: *
Disallow: /
A proper production robots.txt:
User-agent: *
Allow: /
Disallow: /api/
Disallow: /admin/
Disallow: /private/
Sitemap: https://example.com/sitemap.xml
Use our Robots.txt & Sitemap Generator to create properly formatted files in seconds.
Core Web Vitals: Performance Is SEO
Google uses Core Web Vitals as a ranking signal. These are real user experience metrics that measure how fast and stable your page loads:
- LCP (Largest Contentful Paint) — How long until the main content loads. Target: under 2.5 seconds
- INP (Interaction to Next Paint) — How responsive the page is to user input. Target: under 200ms
- CLS (Cumulative Layout Shift) — How much the layout shifts while loading. Target: under 0.1
Common developer causes of poor vitals:
- Images without width/height attributes (causes layout shift)
- Render-blocking JavaScript in the
<head> - Unoptimized images (serving 4000px images for 400px containers)
- Third-party scripts (analytics, ads, chat widgets) loading synchronously
- Web fonts that block text rendering (use
font-display: swap) - Client-side data fetching that delays content rendering
The SPA Problem: JavaScript Rendering
This is the biggest technical SEO mistake developers make. If your content only exists after JavaScript executes, Google may never see it.
Google can render JavaScript, but it's slower and less reliable than parsing HTML. Googlebot uses a two-phase indexing process: first it reads the HTML, then it queues a second pass to render JavaScript. That second pass can take days or weeks. If your entire page is a blank <div id="root"> until React mounts, Google's first impression of your page is an empty page.
Solutions, in order of preference:
- Server-Side Rendering (SSR) — Pages render on the server and arrive as complete HTML. Next.js, Nuxt, and Remix do this
- Static Site Generation (SSG) — Pages are pre-built at build time. Fastest option for content that doesn't change per-request
- Incremental Static Regeneration (ISR) — Static pages that revalidate periodically. Good for frequently updated content
- Pre-rendering services — Last resort for pure SPAs. Services like Prerender.io serve static HTML to bots
Mobile-First Indexing
Google uses the mobile version of your site for indexing and ranking. Not the desktop version. If your mobile experience is degraded — missing content, broken layouts, slower load times — that's what Google sees as your "real" site.
Common mistakes: hiding content behind "Read more" buttons on mobile (Google may not count hidden content), using hover-only interactions, serving different content to mobile vs desktop, and forgetting the viewport meta tag:
<meta name="viewport" content="width=device-width, initial-scale=1" />
Developer SEO Mistakes That Kill Rankings
Here's a rapid-fire list of technical SEO mistakes I see in developer-built sites:
- Infinite scroll without pagination — Googlebot can't scroll. If content loads on scroll, use paginated URLs as fallback (
/blog?page=2) - Wrong status codes — Returning 200 for custom 404 pages (soft 404). Returning 302 instead of 301 for permanent redirects. These confuse crawlers
- Broken internal links — Links to pages that no longer exist. Google follows every link on your site and tracks dead ends
- Missing alt text on images — Google can't see images. Alt text is how it understands them. Also an accessibility requirement
- Hash-based routing — URLs like
example.com/#/aboutare invisible to Google. Everything after # is ignored by crawlers - No HTTPS — Google has confirmed HTTPS is a ranking signal. There's no reason not to use it (Let's Encrypt is free)
- Slow TTFB — Time to First Byte over 600ms signals server problems. Optimize database queries, add caching, use a CDN
Content vs Technical SEO
Developers focus on technical SEO (page speed, structured data, sitemaps) and ignore content SEO. Marketers focus on content SEO (keywords, blog posts, backlinks) and ignore technical SEO. You need both.
Technical SEO is the foundation. Content SEO is the building. A perfectly optimized site with no content won't rank. A content-rich site with broken technical SEO won't rank either.
The minimum viable SEO checklist for developers:
- Unique title tag and meta description on every page
- Canonical URLs on every page
- Valid sitemap.xml submitted to Google Search Console
- Clean robots.txt that doesn't block important content
- Server-side rendering or static generation for all indexable pages
- Proper HTTP status codes (301 for permanent redirects, 404 for missing pages)
- Core Web Vitals in the green (LCP < 2.5s, INP < 200ms, CLS < 0.1)
- Mobile-responsive design with viewport meta tag
- HTTPS everywhere
- Structured data for key page types
Measuring SEO Success
SEO takes time. Expecting results in a week is like expecting muscle growth after one gym session. Here's what to track and when to expect changes:
- Google Search Console — your primary tool. Shows impressions, clicks, average position, and indexing status. Check it weekly
- Index coverage — are your pages being indexed? If Google is ignoring pages, fix the technical issues first
- Organic traffic trend — month-over-month growth. Ignore daily fluctuations
- Keyword rankings — track your target keywords. Aim for page 1 (positions 1-10) over 3-6 months
- Core Web Vitals report — Google surfaces this in Search Console. Fix any URLs in the "Poor" category first
Typical timeline: technical SEO fixes show impact in 2-4 weeks. New content starts ranking in 2-6 months. Authority builds over 6-12 months. There are no shortcuts.
Tools to Check Your SEO
You don't need expensive SEO tools to get started. Use our free tools to audit the basics:
- SEO Checker — Analyze any page for title tags, meta descriptions, heading structure, and common SEO issues
- Meta Tag Generator — Generate properly formatted title, description, Open Graph, and Twitter Card tags
- Robots.txt & Sitemap Generator — Create valid robots.txt and sitemap.xml files with the right directives
SEO is an ongoing practice, not a one-time setup. Start with the technical foundation — proper meta tags, canonical URLs, a valid sitemap, and server-rendered pages. Then build content that answers the questions your audience is actually searching for. Use our free SEO Checker, Meta Tag Generator, and Robots & Sitemap Generator to audit and fix the basics today.
We build free developer tools and write about AI, automation, and developer productivity. 30 tools, 33 articles, and an AI Prompt Engine — all built to help workers navigate the AI era. Published by Salty Rantz LLC.
The IT Hustle Weekly
What changed in AI this week and what it means for your job. Free tools, honest reviews, zero spam.
Generate Your Own Anti-Hallucination Prompts
Our AI Prompt Engine uses patent-pending technology to generate prompts with built-in verification and contradiction testing.
Try 3 Free Generations →