Be Found First, Then Rank: SEO and Discoverability in Practice for Your Vibe Project
A four-step funnel — discovery, indexing, ranking, clicks: unique titles and descriptions per page, semantic HTML, sitemaps, JSON-LD, the client-side rendering trap, Core Web Vitals; fictional funnel 1000→820→540→260→120 and a 15-item launch checklist.

Three things up front, so you don't read the wrong guide. First, this guide is not about the content growth flywheel — the site already has "Solo Content Growth Flywheel," which covers producing content steadily and rolling traffic upward; this guide covers the earlier step: can a search engine find your pages, index them, and rank them at all, before any growth talk. Second, this guide is not about competitor research — the site already has "AI Competitor Research Workflow," a one-day, three-phase method for studying rivals; this guide is only about your own site and how to make search engines understand it. Third, this guide is not about caching strategy — the site already has "Vibe Project Caching Strategy"; caching lives there, and this guide only mentions image size and loading in passing when it talks about performance signals. The site also already has three guides with SEO in the name, and this one is different from all of them: "SEO and AEO in Practice" is about AI search and making your site readable to agents; "SEO Content Growth Guide" is about programmatic pages and three growth moves; "SEO in Practice for AI-Generated Sites" is a 30-item technical checklist. This guide does not cover the AI discovery layer, does not cover bulk programmatic page production, and does not try to have the longest checklist; it covers one thing: the full path for a vibe project from "unfindable" to "findable, and clicked" — discovery, indexing, ranking, and clicks, four steps, each with something you can change by hand, plus a launch acceptance checklist at the end. The whole guide uses one fictional example to make the ideas concrete: the example product is "PickLight Recipes," a practice app that lets users save home recipes and find dishes from the ingredients they already have; the example author is "A-Li," an office worker who likes to cook; the numbers, conversations, and scenes in the example are entirely fictional exercises, written to make the ideas concrete, not a real product or real events. The funnel numbers in the last section are also a fictional sample, used to do the math, not real data.
Is your project invisible in search?
A-Li spent three weekends building a small recipe app with an AI helper: the home page shows today's picks, tapping one opens the steps, and you can search backwards from the ingredients left in your fridge to find what you can cook. She shared the link with friends, and everyone said it worked well. A month later, curious, she typed "30-minute home recipes" into a search box and flipped through page after page — her site was nowhere, even ten pages down. She tried searching for the site's own name. Nothing. Her project was not bad; to a search engine, it simply did not exist.
This is how many vibe projects die: the product runs, the link opens, but a search engine has never visited, or visited and understood nothing. When authors write code, they think about what users see after clicking; a search engine thinks about something else: what the page is called, what it is about, how it relates to other pages, and whether it is worth recommending to someone searching for that phrase. When the two views do not line up, the project can only survive on links the author shares by hand, and the moment the sharing stops, the traffic drops to zero.
A search engine's work splits into four steps, and your page can be filtered out at any of them. First is discovery: crawlers follow links to find your page. Second is indexing: the crawler reads the content and decides whether to put it in the index. Third is ranking: for a given query, it decides where your page sits. Fourth is the click: the user sees your title and description on the results page and decides whether to click. Many beginners only stare at step three, ranking, desperate to reach number one, without knowing their page is stuck at step one and has never even been discovered. The right order for SEO is to make sure no step drops you first, and only then talk about moving up.
Look at the funnel first: which step is your page dying at?
Before changing anything, give your own site a checkup and locate the step where it dies. The most direct method is to type site:yourdomain into a search box and see how many results come back. If none come back, check steps one and two first: can the crawler get in, and can the page be read. If a few come back, look at how they rank: does searching your site's name put you first, and does searching your core phrase get you into the top fifty? If even your own name does not rank first, the problem is usually titles and indexing; if your core phrase cannot reach the top fifty, then talk about content and links.
That is how A-Li checked. One month after launch, a site: search returned only the home page. The server logs showed the crawler had visited four times in a month and each time only fetched the home page and left. The home page title was "Welcome to PickLight Recipes," the description was empty, there were no links between inner pages, and recipe detail pages only rendered after a button click ran a script. The crawler arrived, saw a shell with a single title, and never learned the recipe pages existed at all. The problem was not whether the content was well written; discovery and indexing had already broken.
She spent a week fixing it the way this guide describes: every recipe page got its own title and description, the home page gained links to category pages and popular recipes, she submitted a sitemap, and recipe details were changed to render on the server. A month later, a site: search returned 96 results, searching the site name ranked first, and searching "tomato egg 30 minutes" reached the top ten. The content was the same content; what changed was whether a search engine could find it and understand it.
Titles and descriptions: the results page is your billboard
On a search results page, users decide using only two things: the title and the description. The title decides whether they glance at you at all; the description decides whether they click. Both are under your control, cost two lines of writing per page, and are the highest-return step in all of SEO.
There are three hard rules for titles. First, every page gets one unique title; never use the same "PickLight Recipes" title across the whole site. The home page can be "PickLight Recipes | 30-Minute Home Recipes," a recipe page "Tomato Egg Stir-Fry | 15-Minute Home Recipe - PickLight Recipes," and a category page "Quick Dinner Recipe Collection - PickLight Recipes." Put the words users actually search for in the title, not the words you personally like. Second, keep titles within 60 characters; anything longer gets cut off on the results page, and the cut part is wasted writing. A-Li's first title was "PickLight Recipes — a little life tool that uses AI to help you record home recipes and find dishes from your ingredients," a full 40 characters that was not wrong in meaning, but a person searching "tomato egg stir-fry" could not tell at a glance which dish the page was about. Third, put the most important words in the first half of the title, because users scan only the first few words before deciding whether to keep reading.
Titles work the same way for descriptions: write one sentence of 150 to 160 characters per page, saying what the page helps the user do, and include the keywords along the way. A description does not directly decide rankings, but it decides click-through rate, and when the click rate is low, even a good ranking slowly slides down. For the tomato egg page, A-Li wrote: "Tomato egg stir-fry in 15 minutes: fry the egg first, then the tomato, add a pinch of sugar before serving. Includes common beginner mistakes and substitute ingredients — follow it once and it works." No fancy words, but anyone searching that phrase can see at once that this is the page they want.
AI-generated content fails most easily right here: bulk-generated pages share one title template, descriptions are all empty, or every page shares the same sentence "Welcome to this site." When a search engine sees a hundred pages with identical titles, it assumes the hundred pages are no different from each other, indexes a few, and throws the rest away as duplicates. There is no shortcut for titles and descriptions: two lines per page, and if you cannot write them, publish fewer pages and write each one properly.
Semantic HTML and heading levels: let the crawler read your page structure
A crawler does not read a page by how pretty it looks; it reads its structure. A page piled up from divs and a page with clear semantics look identical in a browser, but to a crawler they are two different things. Semantic tags are how you tell the crawler: this block is navigation, that block is the body, this line is a heading, that part is a list.
Four basic rules. First, use only one h1 per page, holding the page's topic — on a recipe page, the h1 is the dish name, "Tomato Egg Stir-Fry." Use h2 for sections such as "Ingredients," "Steps," and "Common Mistakes," and h3 one level further down. Heading levels must not skip, and must not be misused for font size: an h4 sitting directly under an h1 tells the crawler content is missing in between, and wrapping a paragraph in h2 just to make the text bigger tells the crawler that paragraph is a section heading, scrambling the whole structure. Second, use nav for navigation, main and article for body content, and footer for the footer. Third, every image needs alt text saying what is in the picture, for example alt="Tomato egg stir-fry served in a white plate." Alt is not only for people who cannot see the image; it is also the crawler's only clue to what an image shows. An image without alt is a black cloth to a search engine. Fourth, link text must say where the link goes — write "See the quick dinner collection," not "click here." Crawlers judge the target page by its link text, and "click here" says nothing at all.
Another common beginner mistake is using images as headings. Turning a dish name into a pretty picture at the top of the page looks great in a browser, but a crawler cannot read the words inside the picture, so your h1 effectively does not exist. Headings are always written as text; images are for decoration. A simple test: turn off all styles and read only the plain text. If the page still makes sense and its structure is still clear, the semantics pass; if switching styles off leaves a pile of text with no levels, fix the structure before anything else.
Sitemaps and robots.txt: draw the crawler a map and put up a sign
A sitemap, sitemap.xml, is a list of the page addresses you want search engines to index. Crawlers normally find pages by following links one by one; with a map, they can work straight down the list, which helps new and small sites most. The format is simple: an XML file, one address per line, placed at the site root, then submitted once in the search engine's webmaster tools. A-Li's site had only 96 pages, so the map was 96 lines with one address each; when pages grow, you can split the map by category and manage them with one index file.
Three easy traps hide in sitemaps. First, only list pages you want indexed — do not stuff in login pages, admin pages, repeated filter pages, or test pages. Stuffing them in tells the crawler those pages matter, and its attention gets divided. Second, addresses must match the real, openable addresses exactly; an address with extra parameters or an inconsistent trailing slash makes the crawler think it is two different pages. Third, a sitemap is not set-and-forget: update it when you publish new pages, or have the build process regenerate it on every deploy. A-Li added a step to her deploy script that regenerates the map automatically on each release.
Robots.txt is a different thing: it sits at the site root and tells crawlers which areas they may not enter, such as admin pages, private messages, and search result pages. It is only a few lines: User-agent: * speaks to all crawlers, Disallow: /admin/ keeps them out of the admin area, and a final line, Sitemap: your map address. Note that robots.txt blocks crawling, not indexing: a page blocked by robots.txt can still have its address indexed if other sites link to it — it just gets no content snippet. Pages you truly do not want indexed need a noindex tag on the page itself, or simply should not appear in any link. One more thing: never use robots.txt to block the whole site. A-Li once saw a beginner project that copied a template line, Disallow: /, and got zero indexed pages in three months — that one line was the problem.
Structured data: use JSON-LD to tell search engines what the page is
Structured data is a machine-readable label placed on a page, written in JSON-LD format inside a script tag, telling a search engine: this page is a recipe called tomato egg stir-fry, it takes 15 minutes, its ingredients are tomato and egg, and its rating is 4.8. With it, search results can show a richer display — cooking time, rating stars, an ingredient list — so users know whether the page is worth clicking before they even open it.
The markup A-Li added to a recipe page looks roughly like this: type Recipe, name, image, a short description of the method, prep time and cook time, an ingredient list, a step list, and the author name. Three things matter when writing it. First, every item in the markup must be genuinely visible on the page. Do not invent a rating or list ingredients that are not on the page just to win a prettier display; search engines check, and if they catch invented data, the whole site can lose its rich-result eligibility. Second, write times in ISO format — 15 minutes as PT15M, not as words — because machines cannot read "15 minutes" in prose. Third, test it first with the search engine's rich results testing tool and fix every error before going live; the tool tells you item by item what is missing or malformed.
Start with the two or three most important page types, and expand once they work. A-Li started with the Recipe type on recipe pages, and the results began showing cooking time and ratings, with a visibly higher click-through rate than before.
The client-side rendering trap: the crawler sees a different page than you do
This is the easiest trap for vibe projects to fall into, and the deadliest. Many AI-assisted projects are purely client-side rendered: the browser first downloads a nearly empty HTML file, then downloads JavaScript, runs it, and only then paints the content. In your browser, the page looks complete; when a crawler arrives, if it leaves before the JavaScript finishes running, all it sees is an empty shell and a "loading" line.
Google's crawler now tries to render JavaScript, but that does not mean you can relax. First, rendering is queued: after the crawler fetches the page, rendering can wait days or even longer, and during that time your page sits in the index with no content. Second, rendering can fail — a script error, an API timeout, a dependency on something only a browser has — and any single failure means the content never appears. Third, other search engines and AI crawlers render unevenly, and you cannot assume they will all wait for your scripts to finish.
The fix is to split by how important the content is. Core content pages — articles, recipes, product introductions, documentation — should use server-side rendering or be generated as static pages at build time, so the crawler sees the complete content at first glance. Highly interactive parts — filters, save buttons, comment boxes — can stay client-side rendered, because they never needed to be indexed in the first place. That is how A-Li changed her recipe detail pages: the dish name, ingredients, and steps are output directly into the HTML on the server, while the save and rating buttons stay on the client. After the change, she used the webmaster tool's URL inspection feature to look at the page through the crawler's eyes: the title, dish name, and steps were all there, not a line missing.
There is a rough way to tell whether your own site has this problem: open the page in a browser, disable JavaScript, refresh, and see whether the core content is still there. If everything is gone, your site is a blank sheet of paper to a crawler. Another way is to view the page source: right-click, view source, and search for a key sentence from the body text. If the sentence is nowhere in the source, the content only appears after scripts run — fix that first.
Performance signals: fast or slow, search engines can see it
Search engines count page experience as a ranking factor, and the best-known three metrics together are called Core Web Vitals: Largest Contentful Paint (LCP), how long the main content takes to appear; Interaction to Next Paint (INP), how long after a tap before there is a response; and Cumulative Layout Shift (CLS), how much the content jumps around while the page loads. They are not guesswork; they are measurable numbers, reported directly by webmaster tools and PageSpeed Insights.
For a small site, LCP is the one to fix first. When A-Li first measured her site, the home page LCP was 4.8 seconds: the first-screen image was 2.4MB, and loading it on a phone took forever. She compressed the home hero image down to 180KB, switched it to a modern format, and added width and height attributes; LCP dropped to 2.1 seconds. These numbers are a fictional exercise sample she measured herself, used to show the order of magnitude — the point is not the numbers 4.8 and 2.1 themselves, but the lesson that one 2.4MB first-screen image can wreck LCP. The concrete steps for image optimization live in a separate guide on this site devoted to images; this guide only states the conclusion: first-screen image size is the most common cause of bad LCP on small sites, so fix it first.
Performance work has no finish line, but for a new site, catching the LCP end is enough: fix the first-screen image and slow APIs first, then fix images without dimensions and jumping layouts. The remaining details can wait until the site grows and traffic rises.
Site search and links: let the crawler walk, and earn links from others
Crawlers discover pages mainly by following links. Your internal links are the crawler's roads; when a road breaks, the page becomes an island. Checking internal links takes three actions. First, every important page needs at least one link pointing to it from another page: the home page links to category pages, category pages link to detail pages, and detail pages link back to related pages at the bottom. Second, write breadcrumbs properly — "Home / Quick Dinners / Tomato Egg Stir-Fry" — which helps users orient themselves and helps crawlers understand the hierarchy between pages. Third, scan for dead links regularly: a link pointing to a 404 page is a dead end, and when a crawler walks into one, it becomes less keen to come back. Site search should not be a decoration either: make sure it can find content by title and ingredient first, and add noindex to the search results pages themselves so they are not indexed.
Outbound links are another matter: when other sites link to you, they are voting to a search engine that your page is worth reading. For a new site, links are not bought, swapped, or mass-mailed; they come from making content worth linking to and letting it happen naturally. A-Li's approach was plain: she wrote a solid article, "Five reasons tomato egg stir-fry fails," shared it in cooking communities, and people who found it useful passed it on, with links attached along the way. She never bought a single link, and within half a year she had dozens of natural links, with rankings for core phrases rising alongside them. Mass-posting in comment sections or buying farm links is the opposite: once a search engine notices, the links at best count for nothing, and at worst drag the whole site down. Do not touch them.
Seven SEO mistakes AI-generated content keeps making
Building a site with an AI helper fails most easily on SEO, because AI aims for "looks finished," while a search engine wants "every page different, every page useful." A-Li stepped on all seven of the mistakes below; you can check them one by one.
First, duplicate titles. Hundreds of pages share one title template across the site, or titles differ only by the site name at the end. Fix: write the content words into every page title, and leave at least two variable slots in the template for each page's own topic words.
Second, empty descriptions. Pages are generated without descriptions, or the whole site shares one sentence. Fix: generate the description together with the title, one sentence per page saying what the page does, kept to 150 to 160 characters.
Third, images without alt. AI-generated image tags often carry no alt, or an alt that just says "image." Fix: write one descriptive sentence per image saying what is in it; only decorative images get an empty alt.
Fourth, client-side rendering that hides content from crawlers. The whole site only gains content after scripts run, leaving the source almost empty. Fix: switch core content pages to server-side rendering or static generation, using the check described in the earlier section.
Fifth, URLs full of meaningless numbers and parameters, such as /page?id=48291, which neither crawlers nor users can read. Fix: put content words in the URL, such as /recipes/tomato-egg-stir-fry — short, readable, and guessable.
Sixth, duplicate content. The same recipe published three times under different titles, or filter, sort, and pagination pages copying the same content across dozens of addresses. Fix: point duplicate pages at one canonical address with a canonical tag, or block unimportant copies with noindex.
Seventh, publish and forget. Pages go live and nobody ever checks indexing, clicks, or dead links again. Fix: look at webmaster tools once a month — how much indexing dropped, which queries brought clicks, which pages have errors — and fix from that list.
A fictional funnel: how many survive each of the four steps?
How well search optimization is working cannot be judged by the final click count alone; you have to look at every step of the funnel. The PickLight Recipes team used a four-step funnel, and the numbers are a fictional sample used to show how the math works. Suppose crawlers discovered 1,000 page addresses in a month: 820 of them were indexed, 82.0%; of those 820, 540 reached the top 50 for their target phrases, 65.9%; of those 540, 260 reached the top 10, 48.1%; and of those 260, 120 were actually clicked by users within the month, 46.2%. Overall, of 1,000 discovered addresses, 120 completed the whole journey from discovery to click — an overall conversion rate of 12.0%. The losses add up too: 180 left after step one, 280 after step two, 280 after step three, and 140 after step four, leaving 120 — 180 plus 280 plus 280 plus 140 plus 120 is exactly 1,000.
Reading a funnel means finding which step drops hardest, not staring at the final total. If step one drops hardest, many pages are never indexed at all, and the problem is sitemaps, internal links, and rendering. If the drop from step two to step three is steepest, pages are indexed but the content does not match the keywords, so go back and fix titles and body text. If step four drops hardest, the ranking is there but nobody clicks, so the problem is titles and descriptions that are not compelling enough. When A-Li first ran this funnel, the steepest drop was step one: of 1,000 addresses, fewer than half were indexed, because recipe detail pages relied entirely on script rendering and the crawler could not see them. After switching to server-side output, the step-one rate rose immediately. That is the funnel's value: it does not tell you whether the site is good; it tells you which step to fix next week.

Launch acceptance checklist: tick every item before publishing
The checklist below is what A-Li now runs through before publishing each new page. Fifteen items, ten minutes to check, checked before anything goes live.
First, every page has a unique title, within 60 characters, with the words users search for in the first half. Second, every page has a description of 150 to 160 characters saying what the page does. Third, one page has only one h1, and h2 and h3 levels do not skip. Fourth, every image has alt text, and decorative images use an empty alt. Fifth, link text says where the link goes; never "click here." Sixth, the sitemap is updated and the new page is in it. Seventh, robots.txt does not accidentally block the whole site, and admin pages are blocked. Eighth, pages that should not be indexed carry noindex, and duplicate pages point to a canonical address. Ninth, structured data has been tested, with no errors, and the markup matches what the page shows. Tenth, refresh once with JavaScript disabled and confirm the core content is still there. Eleventh, the home page LCP has been measured, and the first-screen image is compressed and has width and height. Twelfth, images carry width and height attributes so the page does not jump while loading. Thirteenth, every important page on the site has at least one internal link pointing to it, and there are no dead links. Fourteenth, URLs carry content words, not meaningless numbers. Fifteenth, the new page has been submitted in webmaster tools, and indexing is checked again a week later.
The list does not need a perfect score on the first try. A new site that manages the first ten items is already ahead of most vibe projects; the last five can be added slowly over the first month after launch. The habit is what matters: run the checklist every time a page goes out, instead of remembering to check three months after launch.
Start with the smallest discovery loop
If you want to start now, do not begin by thinking about how to rank first. Build the smallest discovery loop first: pick three to five of your most important pages, write their titles and descriptions properly, give them clean semantic structure, confirm crawlers can see the content, submit the sitemap, and wait a week to see whether they get indexed. PickLight Recipes' first SEO loop had only four tasks: titles and descriptions for the home page and three signature recipes, a sitemap, server-side output for recipe pages, and a webmaster tools submission. Four tasks, one weekend, and once it worked, structured data, internal links, and performance work were added gradually.
Back to A-Li. She now looks at webmaster tools once a month, no longer staring at the ranking of any single phrase, but at the funnel: how many pages were discovered this month, how many indexed, how many reached the top ten, and how many were clicked. Whichever step drops hardest gets fixed the next month. Her site has never trended, and she has never bought a single link, but searching "30-minute home recipes" keeps her site on the first page.
Comments (0)
Sources
Related articles
localStorage only stores strings and has no indexes. IndexedDB is a real database in the browser: structured data, far larger capacity, indexes, and transactions. Following MDN's Using IndexedDB, IDBDatabase, and IDBObjectStore: the five-step routine, opening, upgrades, keys, indexes, transactions, add versus put, get, cursors, ranges, and multi-tab upgrades.
You already call functions every day; this guide names what you have been doing. Following MDN's Functions, Arrow function expressions, and Rest parameters: declarations versus expressions, parameters and arguments, default values, rest parameters, spread syntax, return values, arrow function shorthand, the this trap, callbacks, and scope.
One page should stand up on a phone, a tablet, and a computer. This guide follows MDN's Responsive web design, Using media queries, and the viewport meta reference: fluid HTML, the viewport tag, fluid grids and max-width, images that never burst their container, media query syntax, breakpoints set by content, mobile first, responsive type, testing capability instead of width, and a pre-launch checklist.