A practical, phase-by-phase checklist covering technical SEO, Core Web Vitals, AI optimization, schema markup, and post-launch indexing — written by a developer, for developers.
SEO has this reputation for being mysterious — like there’s some secret formula that only marketing people understand. In practice, most of it comes down to building your site correctly from the start and making sure Google can actually read what you built. That’s it.
This checklist is what I go through whenever I’m shipping a site. It’s split into four stages: decisions you make before writing a single line of code, things you handle during development, the newer stuff around AI-generated search results, and finally what to do after you launch. Skip a stage and you’ll probably be fine short-term, but you’ll pay for it later.
Before You Write Any Code
The decisions here are the ones that are painful to undo. Get them wrong and you’re looking at redirects, refactors, and URL migrations six months down the road.
HTTPS is non-negotiable. Google has been using HTTPS as a ranking signal for years, and browsers now actively warn users on HTTP sites. Get a certificate from Let’s Encrypt (it’s free), and once you have it, add an HSTS header so browsers stop even trying plain HTTP:
Strict-Transport-Security: max-age=31536000; includeSubDomainsThen check your browser console for mixed-content warnings — those will bite you later.
Design for mobile first, not as an afterthought. Google crawls your mobile version and uses it for ranking. This doesn’t mean just “make it responsive.” It means your smallest viewport should be your primary design target. A layout that works at 375px wide and then scales up is going to serve you much better than a desktop design squeezed down. Use Chrome DevTools device mode during development, not just at the end.
Keep your URLs clean. Short, lowercase, hyphens between words, no query parameters for permanent content pages. Compare /blog/core-web-vitals-guide against /page?id=482&category=technical-seo — one of those tells the user and Google something useful, the other tells them nothing. Once you pick a URL structure, stick with it. Changing URLs later means setting up redirects, which means lost link equity, which means a rankings dip.
Every important page should be reachable in three clicks or fewer from your homepage. If a page is buried six levels deep, crawlers visit it infrequently and users rarely find it. Sketch out your site structure before building. Add breadcrumbs too — they help both crawlers and actual humans understand where they are.
Technical SEO While You’re Building
This is where most developers either build a really solid foundation or accidentally create a mess they don’t notice for months.
One <h1> per page. One. That’s the page title. Your <h2> tags should cover the main topics, <h3> covers sub-topics under those, and so on. Never jump from <h1> straight to <h3> — screen readers and search engines use heading structure the same way readers skim a document.
Meta tags that actually work. Every page needs a unique <title> (under 60 characters, or it gets cut off in search results) and a <meta description> (under 155 characters). Write it like it needs to earn a click, not just summarize the page.
<title>Core Web Vitals Explained for Developers (2026) | Kodingus</title>
<meta name="description" content="LCP, INP, and CLS explained with real causes and fixes — the stuff PageSpeed Insights actually flags on production sites." />Canonical tags on every page. A canonical tag tells Google which version is the real one:
<link rel="canonical" href="https://example.com/blog/post" />Put this in <head> on every page. Automated — don’t think about it per-page.
Images optimization best practices:
- Use WebP or AVIF instead of JPEG/PNG.
- Compress before uploading (under 100 KB).
- Always include descriptive
alttext. - Add
loading="lazy"to images below the fold.
Core Web Vitals target verification:
| Metric | What it actually measures | Target |
|---|---|---|
| LCP (Largest Contentful Paint) | How fast the main content loads | Under 2.5 seconds |
| INP (Interaction to Next Paint) | How fast the page responds to user input | Under 200ms |
| CLS (Cumulative Layout Shift) | Whether content jumps around while loading | Under 0.1 |
Measure with PageSpeed Insights before launch, and check the Core Web Vitals report in Google Search Console for real-user data after.
Making Your Content Work with AI Search (GEO)
This is newer territory. Beyond just ranking in the ten blue links, content now needs to be understandable enough for AI systems — Google AI Overviews, Perplexity, ChatGPT — to pull from it accurately.
Schema markup tells AI what your content is. Add JSON-LD structured data in a script tag in your page head. For blog posts, Article schema is the baseline:
{
"@context": "https://schema.org",
"@type": "Article",
"headline": "Your Post Title",
"author": { "@type": "Person", "name": "Your Name" },
"datePublished": "2026-07-11",
"publisher": {
"@type": "Organization",
"name": "Kodingus",
"url": "https://kodingus.com"
}
}For FAQ-style content, FAQPage schema significantly improves your chances of appearing in AI Overviews:
{
"@context": "https://schema.org",
"@type": "FAQPage",
"mainEntity": [{
"@type": "Question",
"name": "What is GEO in SEO?",
"acceptedAnswer": {
"@type": "Answer",
"text": "GEO stands for Generative Engine Optimization — the practice of writing and structuring content so AI systems can accurately extract and cite it."
}
}]
}Structure your content like you’re answering questions. AI Overviews and featured snippets almost always pull from pages where a heading frames a question and the first paragraph directly answers it.
E-E-A-T matters more than it used to. Experience, Expertise, Authoritativeness, Trustworthiness — write author bios, link to your sources, have a contact page and privacy policy.
Use real HTML structure for important content. Lists, tables, numbered steps — these should be actual <ul>, <ol>, and <table> elements, not divs styled to look like them.
After Launch: Getting Indexed
You can do everything else right and still have a site that Google can’t find or won’t index.
Check your robots.txt before anything else. Make sure it allows crawlers in production:
User-agent: *
Disallow:
Sitemap: https://yourdomain.com/sitemap.xmlGenerate a clean XML sitemap. Include only HTTP 200 URLs. Submit in Google Search Console.
Internal linking optimization. Ensure descriptive anchor text and proper link flow.
Google Search Console setup. Verify domain ownership, submit sitemap, and request indexing.
The Quick Checklist
Use this interactive checklist to audit your site stage by stage:
- SSL & HSTS: HTTPS active with HSTS header set
- Mobile-First Layout: Tested and verified at 375px viewport
- Clean URL Structure: Lowercase, hyphens, no query params
- Site Hierarchy: Reachable within 3 clicks from homepage with breadcrumbs
- Heading Structure: Single
<h1>and clean<h2>/<h3>hierarchy - Meta Tags: Unique
<title>(≤60 chars) &<meta description>(≤155 chars) - Canonical Tag: Included in
<head>on every page - Image Optimization: WebP/AVIF, <100 KB, alt text, lazy loading
- Core Web Vitals: LCP < 2.5s, INP < 200ms, CLS < 0.1
- Schema Markup: JSON-LD (Article / FAQPage) installed
- AI-Friendly Content: Questions in
<h2>with immediate paragraph answers - E-E-A-T Signals: Author bios, contact, and privacy policy active
- Semantic HTML: Proper
<ul>,<ol>, and<table>elements used - Robots.txt: Verified allowing production crawlers
- XML Sitemap: Clean 200 OK sitemap submitted to Google Search Console
- Internal Links: Descriptive anchor text connecting published pages
- Search Console Indexing: Domain verified and initial indexing requested
None of this is magic. It’s just being deliberate about how you build things. The sites that consistently outrank competitors aren’t doing anything exotic — they’re doing these fundamentals well, consistently, over time.